diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index ec421f2..fb3e118 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -3,23 +3,30 @@ repos: rev: 24.3.0 hooks: - id: black + exclude: '\.ipynb$' # Ignore notebooks - repo: https://github.com/nbQA-dev/nbQA rev: 1.7.0 hooks: - id: nbqa-black additional_dependencies: [black, setuptools] + exclude: '\.ipynb$' - id: nbqa-isort additional_dependencies: [isort, setuptools] + exclude: '\.ipynb$' - id: nbqa-flake8 additional_dependencies: [flake8, setuptools] + exclude: '\.ipynb$' - repo: https://github.com/PyCQA/isort rev: 5.13.2 hooks: - id: isort + exclude: '\.ipynb$' - repo: https://github.com/pycqa/flake8 rev: 6.1.0 hooks: - - id: flake8 \ No newline at end of file + - id: flake8 + exclude: '\.ipynb$' + diff --git a/data_dir/datasets.py b/data_dir/datasets.py index cca6eab..3ea5c52 100644 --- a/data_dir/datasets.py +++ b/data_dir/datasets.py @@ -140,60 +140,61 @@ def dataset_generator( val_data, val_labels = data[idxs[1]], labels[idxs[1]] test_data, test_labels = None, None + if include_time: + ts_train = train_data[:, :, 0] + ts_val = val_data[:, :, 0] + ts_test = test_data[:, :, 0] + else: + ts_train = (T / train_data.shape[1]) * jnp.repeat( + jnp.arange(train_data.shape[1])[None, :], train_data.shape[0], axis=0 + ) + ts_val = (T / val_data.shape[1]) * jnp.repeat( + jnp.arange(val_data.shape[1])[None, :], val_data.shape[0], axis=0 + ) + ts_test = (T / test_data.shape[1]) * jnp.repeat( + jnp.arange(test_data.shape[1])[None, :], test_data.shape[0], axis=0 + ) + train_paths = batch_calc_paths(train_data, stepsize, depth) val_paths = batch_calc_paths(val_data, stepsize, depth) test_paths = batch_calc_paths(test_data, stepsize, depth) - intervals = jnp.arange(0, train_data.shape[1], stepsize) - intervals = jnp.concatenate((intervals, jnp.array([train_data.shape[1]]))) - intervals = intervals * (T / train_data.shape[1]) + indexes = np.unique(np.r_[0 : train_data.shape[1] : stepsize]) + intervals = ts_train[0, indexes] + intervals = jnp.concatenate((intervals, jnp.array([T]))) train_coeffs = calc_coeffs(train_data, include_time, T) val_coeffs = calc_coeffs(val_data, include_time, T) test_coeffs = calc_coeffs(test_data, include_time, T) train_coeff_data = ( - (T / train_data.shape[1]) - * jnp.repeat( - jnp.arange(train_data.shape[1])[None, :], train_data.shape[0], axis=0 - ), + ts_train, train_coeffs, train_data[:, 0, :], ) val_coeff_data = ( - (T / val_data.shape[1]) - * jnp.repeat(jnp.arange(val_data.shape[1])[None, :], val_data.shape[0], axis=0), + ts_val, val_coeffs, val_data[:, 0, :], ) if idxs is None: test_coeff_data = ( - (T / test_data.shape[1]) - * jnp.repeat( - jnp.arange(test_data.shape[1])[None, :], test_data.shape[0], axis=0 - ), + ts_test, test_coeffs, test_data[:, 0, :], ) train_path_data = ( - (T / train_data.shape[1]) - * jnp.repeat( - jnp.arange(train_data.shape[1])[None, :], train_data.shape[0], axis=0 - ), + ts_train, train_paths, train_data[:, 0, :], ) val_path_data = ( - (T / val_data.shape[1]) - * jnp.repeat(jnp.arange(val_data.shape[1])[None, :], val_data.shape[0], axis=0), + ts_val, val_paths, val_data[:, 0, :], ) if idxs is None: test_path_data = ( - (T / test_data.shape[1]) - * jnp.repeat( - jnp.arange(test_data.shape[1])[None, :], test_data.shape[0], axis=0 - ), + ts_test, test_paths, test_data[:, 0, :], ) @@ -234,7 +235,7 @@ def dataset_generator( def _scale_to_minus_one_one(x, data_min, data_max, eps=1e-8): - """Affine‑maps x from [data_min,data_max] → [‑1,1] with broadcasting.""" + """Affine-maps x from [data_min,data_max] → [-1,1] with broadcasting.""" return 2.0 * (x - data_min) / (data_max - data_min + eps) - 1.0 @@ -266,18 +267,13 @@ def create_uea_dataset( test_data = pickle.load(f) with open(data_dir + f"/processed/UEA/{name}/y_test.pkl", "rb") as f: test_labels = pickle.load(f) + t = (T / train_data.shape[1]) * jnp.arange(train_data.shape[1])[None, :] if include_time: - ts = (T / train_data.shape[1]) * jnp.repeat( - jnp.arange(train_data.shape[1])[None, :], train_data.shape[0], axis=0 - ) + ts = jnp.repeat(t, train_data.shape[0], axis=0) train_data = jnp.concatenate([ts[:, :, None], train_data], axis=2) - ts = (T / val_data.shape[1]) * jnp.repeat( - jnp.arange(val_data.shape[1])[None, :], val_data.shape[0], axis=0 - ) + ts = jnp.repeat(t, val_data.shape[0], axis=0) val_data = jnp.concatenate([ts[:, :, None], val_data], axis=2) - ts = (T / test_data.shape[1]) * jnp.repeat( - jnp.arange(test_data.shape[1])[None, :], test_data.shape[0], axis=0 - ) + ts = jnp.repeat(t, test_data.shape[0], axis=0) test_data = jnp.concatenate([ts[:, :, None], test_data], axis=2) data = (train_data, val_data, test_data) onehot_labels = (train_labels, val_labels, test_labels) @@ -286,6 +282,7 @@ def create_uea_dataset( data = pickle.load(f) with open(data_dir + f"/processed/UEA/{name}/labels.pkl", "rb") as f: labels = pickle.load(f) + t = (T / data.shape[1]) * jnp.arange(data.shape[1])[None, :] onehot_labels = jnp.zeros((len(labels), len(jnp.unique(labels)))) onehot_labels = onehot_labels.at[jnp.arange(len(labels)), labels].set(1) if use_idxs: @@ -295,9 +292,7 @@ def create_uea_dataset( idxs = None if include_time: - ts = (T / data.shape[1]) * jnp.repeat( - jnp.arange(data.shape[1])[None, :], data.shape[0], axis=0 - ) + ts = jnp.repeat(t, data.shape[0], axis=0) data = jnp.concatenate([ts[:, :, None], data], axis=2) if scale: diff --git a/experiment_configs/repeats/bd_linear_ncde/EigenWorms.json b/experiment_configs/repeats/bd_linear_ncde/EigenWorms.json index bbd55ec..c96de48 100644 --- a/experiment_configs/repeats/bd_linear_ncde/EigenWorms.json +++ b/experiment_configs/repeats/bd_linear_ncde/EigenWorms.json @@ -26,5 +26,6 @@ "lambd": 0.001, "block_size": 4, "stepsize": 12, - "depth": 2 + "depth": 2, + "parallel_steps": 128 } diff --git a/experiment_configs/repeats/bd_linear_ncde/EthanolConcentration.json b/experiment_configs/repeats/bd_linear_ncde/EthanolConcentration.json index 726a504..7badfa1 100644 --- a/experiment_configs/repeats/bd_linear_ncde/EthanolConcentration.json +++ b/experiment_configs/repeats/bd_linear_ncde/EthanolConcentration.json @@ -26,5 +26,6 @@ "block_size": 4, "depth": 1, "stepsize": 1, - "lambd": 0.000001 + "lambd": 0.000001, + "parallel_steps": 128 } diff --git a/experiment_configs/repeats/bd_linear_ncde/Heartbeat.json b/experiment_configs/repeats/bd_linear_ncde/Heartbeat.json index 95d4b4a..2095fc7 100644 --- a/experiment_configs/repeats/bd_linear_ncde/Heartbeat.json +++ b/experiment_configs/repeats/bd_linear_ncde/Heartbeat.json @@ -26,5 +26,6 @@ "block_size": 4, "depth": 2, "stepsize": 2, - "lambd": 0.000001 + "lambd": 0.000001, + "parallel_steps": 128 } diff --git a/experiment_configs/repeats/bd_linear_ncde/MotorImagery.json b/experiment_configs/repeats/bd_linear_ncde/MotorImagery.json index 6dcf39d..e6b8cd9 100644 --- a/experiment_configs/repeats/bd_linear_ncde/MotorImagery.json +++ b/experiment_configs/repeats/bd_linear_ncde/MotorImagery.json @@ -26,5 +26,6 @@ "block_size": 4, "depth": 2, "stepsize": 16, - "lambd": 0.001 + "lambd": 0.001, + "parallel_steps": 128 } diff --git a/experiment_configs/repeats/bd_linear_ncde/SelfRegulationSCP1.json b/experiment_configs/repeats/bd_linear_ncde/SelfRegulationSCP1.json index 0c70112..dcfd9d8 100644 --- a/experiment_configs/repeats/bd_linear_ncde/SelfRegulationSCP1.json +++ b/experiment_configs/repeats/bd_linear_ncde/SelfRegulationSCP1.json @@ -26,5 +26,6 @@ "block_size": 4, "stepsize": 16, "depth": 2, - "lambd": 0.0 + "lambd": 0.0, + "parallel_steps": 128 } diff --git a/experiment_configs/repeats/bd_linear_ncde/SelfRegulationSCP2.json b/experiment_configs/repeats/bd_linear_ncde/SelfRegulationSCP2.json index 4f6972e..9ac7ecd 100644 --- a/experiment_configs/repeats/bd_linear_ncde/SelfRegulationSCP2.json +++ b/experiment_configs/repeats/bd_linear_ncde/SelfRegulationSCP2.json @@ -26,5 +26,6 @@ "block_size": 4, "stepsize": 4, "depth": 2, - "lambd": 0.001 + "lambd": 0.001, + "parallel_steps": 128 } diff --git a/experiment_configs/repeats/dense_linear_ncde/EigenWorms.json b/experiment_configs/repeats/dense_linear_ncde/EigenWorms.json index b09098b..bbd8ecf 100644 --- a/experiment_configs/repeats/dense_linear_ncde/EigenWorms.json +++ b/experiment_configs/repeats/dense_linear_ncde/EigenWorms.json @@ -12,7 +12,7 @@ "num_steps": 100000, "print_steps": 1000, "early_stopping_steps": 10, - "batch_size": 16, + "batch_size": 32, "model_name": "linear_ncde", "metric": "accuracy", "classification": true, @@ -26,5 +26,6 @@ "lambd": 0.001, "block_size": 128, "stepsize": 12, - "depth": 2 + "depth": 2, + "parallel_steps": 128 } diff --git a/experiment_configs/repeats/dense_linear_ncde/EthanolConcentration.json b/experiment_configs/repeats/dense_linear_ncde/EthanolConcentration.json index 7c1aec5..a9f88a3 100644 --- a/experiment_configs/repeats/dense_linear_ncde/EthanolConcentration.json +++ b/experiment_configs/repeats/dense_linear_ncde/EthanolConcentration.json @@ -26,5 +26,6 @@ "block_size": 64, "depth": 1, "stepsize": 1, - "lambd": 0.000001 + "lambd": 0.000001, + "parallel_steps": 128 } diff --git a/experiment_configs/repeats/dense_linear_ncde/Heartbeat.json b/experiment_configs/repeats/dense_linear_ncde/Heartbeat.json index a488b7e..7c3c88e 100644 --- a/experiment_configs/repeats/dense_linear_ncde/Heartbeat.json +++ b/experiment_configs/repeats/dense_linear_ncde/Heartbeat.json @@ -26,5 +26,6 @@ "block_size": 16, "depth": 2, "stepsize": 2, - "lambd": 0.000001 + "lambd": 0.000001, + "parallel_steps": 128 } diff --git a/experiment_configs/repeats/dense_linear_ncde/MotorImagery.json b/experiment_configs/repeats/dense_linear_ncde/MotorImagery.json index a2d303c..093d24a 100644 --- a/experiment_configs/repeats/dense_linear_ncde/MotorImagery.json +++ b/experiment_configs/repeats/dense_linear_ncde/MotorImagery.json @@ -26,5 +26,6 @@ "block_size": 16, "depth": 2, "stepsize": 16, - "lambd": 0.001 + "lambd": 0.001, + "parallel_steps": 128 } diff --git a/experiment_configs/repeats/dense_linear_ncde/SelfRegulationSCP1.json b/experiment_configs/repeats/dense_linear_ncde/SelfRegulationSCP1.json index 2667ab8..5fac843 100644 --- a/experiment_configs/repeats/dense_linear_ncde/SelfRegulationSCP1.json +++ b/experiment_configs/repeats/dense_linear_ncde/SelfRegulationSCP1.json @@ -26,5 +26,6 @@ "block_size": 64, "stepsize": 16, "depth": 2, - "lambd": 0.0 + "lambd": 0.0, + "parallel_steps": 128 } diff --git a/experiment_configs/repeats/dense_linear_ncde/SelfRegulationSCP2.json b/experiment_configs/repeats/dense_linear_ncde/SelfRegulationSCP2.json index f7ab867..d149a1a 100644 --- a/experiment_configs/repeats/dense_linear_ncde/SelfRegulationSCP2.json +++ b/experiment_configs/repeats/dense_linear_ncde/SelfRegulationSCP2.json @@ -26,5 +26,6 @@ "block_size": 128, "stepsize": 4, "depth": 2, - "lambd": 0.001 + "lambd": 0.001, + "parallel_steps": 128 } diff --git a/experiment_configs/repeats/diagonal_dense_linear_ncde/EigenWorms.json b/experiment_configs/repeats/diagonal_dense_linear_ncde/EigenWorms.json new file mode 100644 index 0000000..a249ef4 --- /dev/null +++ b/experiment_configs/repeats/diagonal_dense_linear_ncde/EigenWorms.json @@ -0,0 +1,35 @@ +{ + "seeds": [ + 2345, + 3456, + 4567, + 5678, + 6789 + ], + "data_dir": "data_dir", + "output_parent_dir": "", + "lr_scheduler": "lambda lr: lr", + "num_steps": 100000, + "print_steps": 1000, + "early_stopping_steps": 10, + "batch_size": 32, + "model_name": "linear_ncde", + "metric": "accuracy", + "classification": true, + "dataset_name": "EigenWorms", + "use_presplit": false, + "T": 1, + "scale": 1, + "time": "True", + "lr": "0.001", + "hidden_dim": "128", + "lambd": 0.001, + "block_size": 16, + "stepsize": 12, + "depth": 2, + "parallel_steps": 128, + "walsh_hadamard": false, + "diagonal_dense": true, + "sparsity": 1.0, + "rank": 0 +} diff --git a/experiment_configs/repeats/diagonal_dense_linear_ncde/EthanolConcentration.json b/experiment_configs/repeats/diagonal_dense_linear_ncde/EthanolConcentration.json new file mode 100644 index 0000000..34c792d --- /dev/null +++ b/experiment_configs/repeats/diagonal_dense_linear_ncde/EthanolConcentration.json @@ -0,0 +1,35 @@ +{ + "seeds": [ + 2345, + 3456, + 4567, + 5678, + 6789 + ], + "data_dir": "data_dir", + "output_parent_dir": "", + "lr_scheduler": "lambda lr: lr", + "num_steps": 100000, + "print_steps": 1000, + "early_stopping_steps": 10, + "batch_size": 32, + "model_name": "linear_ncde", + "metric": "accuracy", + "classification": true, + "dataset_name": "EthanolConcentration", + "use_presplit": false, + "T": 1, + "scale": 1, + "time": "True", + "lr": "0.0001", + "hidden_dim": "64", + "block_size": 16, + "depth": 1, + "stepsize": 1, + "lambd": 0.000001, + "parallel_steps": 128, + "walsh_hadamard": false, + "diagonal_dense": true, + "sparsity": 1.0, + "rank": 0 +} diff --git a/experiment_configs/repeats/diagonal_dense_linear_ncde/Heartbeat.json b/experiment_configs/repeats/diagonal_dense_linear_ncde/Heartbeat.json new file mode 100644 index 0000000..1c0204f --- /dev/null +++ b/experiment_configs/repeats/diagonal_dense_linear_ncde/Heartbeat.json @@ -0,0 +1,35 @@ +{ + "seeds": [ + 2345, + 3456, + 4567, + 5678, + 6789 + ], + "data_dir": "data_dir", + "output_parent_dir": "", + "lr_scheduler": "lambda lr: lr", + "num_steps": 100000, + "print_steps": 1000, + "early_stopping_steps": 10, + "batch_size": 32, + "model_name": "linear_ncde", + "metric": "accuracy", + "classification": true, + "dataset_name": "Heartbeat", + "use_presplit": false, + "T": 1, + "scale": 1, + "time": "True", + "lr": "0.001", + "hidden_dim": "16", + "block_size": 16, + "depth": 2, + "stepsize": 2, + "lambd": 0.000001, + "parallel_steps": 128, + "walsh_hadamard": false, + "diagonal_dense": false, + "sparsity": 1.0, + "rank": 0 +} diff --git a/experiment_configs/repeats/diagonal_dense_linear_ncde/MotorImagery.json b/experiment_configs/repeats/diagonal_dense_linear_ncde/MotorImagery.json new file mode 100644 index 0000000..8760627 --- /dev/null +++ b/experiment_configs/repeats/diagonal_dense_linear_ncde/MotorImagery.json @@ -0,0 +1,35 @@ +{ + "seeds": [ + 2345, + 3456, + 4567, + 5678, + 6789 + ], + "data_dir": "data_dir", + "output_parent_dir": "", + "lr_scheduler": "lambda lr: lr", + "num_steps": 100000, + "print_steps": 1000, + "early_stopping_steps": 10, + "batch_size": 32, + "model_name": "linear_ncde", + "metric": "accuracy", + "classification": true, + "dataset_name": "MotorImagery", + "use_presplit": false, + "T": 1, + "scale": 1, + "time": "False", + "lr": "0.001", + "hidden_dim": "16", + "block_size": 16, + "depth": 2, + "stepsize": 16, + "lambd": 0.001, + "parallel_steps": 128, + "walsh_hadamard": false, + "diagonal_dense": false, + "sparsity": 1.0, + "rank": 0 +} diff --git a/experiment_configs/repeats/diagonal_dense_linear_ncde/SelfRegulationSCP1.json b/experiment_configs/repeats/diagonal_dense_linear_ncde/SelfRegulationSCP1.json new file mode 100644 index 0000000..2d6d98b --- /dev/null +++ b/experiment_configs/repeats/diagonal_dense_linear_ncde/SelfRegulationSCP1.json @@ -0,0 +1,35 @@ +{ + "seeds": [ + 2345, + 3456, + 4567, + 5678, + 6789 + ], + "data_dir": "data_dir", + "output_parent_dir": "", + "lr_scheduler": "lambda lr: lr", + "num_steps": 100000, + "print_steps": 1000, + "early_stopping_steps": 10, + "batch_size": 32, + "model_name": "linear_ncde", + "metric": "accuracy", + "classification": true, + "dataset_name": "SelfRegulationSCP1", + "use_presplit": false, + "T": 1, + "scale": 1, + "time": "False", + "lr": "0.0001", + "hidden_dim": "64", + "block_size": 16, + "stepsize": 16, + "depth": 2, + "lambd": 0.0, + "parallel_steps": 128, + "walsh_hadamard": false, + "diagonal_dense": true, + "sparsity": 1.0, + "rank": 0 +} diff --git a/experiment_configs/repeats/diagonal_dense_linear_ncde/SelfRegulationSCP2.json b/experiment_configs/repeats/diagonal_dense_linear_ncde/SelfRegulationSCP2.json new file mode 100644 index 0000000..a598d1a --- /dev/null +++ b/experiment_configs/repeats/diagonal_dense_linear_ncde/SelfRegulationSCP2.json @@ -0,0 +1,35 @@ +{ + "seeds": [ + 2345, + 3456, + 4567, + 5678, + 6789 + ], + "data_dir": "data_dir", + "output_parent_dir": "", + "lr_scheduler": "lambda lr: lr", + "num_steps": 100000, + "print_steps": 1000, + "early_stopping_steps": 10, + "batch_size": 32, + "model_name": "linear_ncde", + "metric": "accuracy", + "classification": true, + "dataset_name": "SelfRegulationSCP2", + "use_presplit": false, + "T": 1, + "scale": 1, + "time": "False", + "lr": "0.0001", + "hidden_dim": "128", + "block_size": 16, + "stepsize": 4, + "depth": 2, + "lambd": 0.001, + "parallel_steps": 128, + "walsh_hadamard": false, + "diagonal_dense": true, + "sparsity": 1.0, + "rank": 0 +} diff --git a/experiment_configs/repeats/diagonal_linear_ncde/EigenWorms.json b/experiment_configs/repeats/diagonal_linear_ncde/EigenWorms.json index 92d5f45..ffea5dd 100644 --- a/experiment_configs/repeats/diagonal_linear_ncde/EigenWorms.json +++ b/experiment_configs/repeats/diagonal_linear_ncde/EigenWorms.json @@ -26,5 +26,6 @@ "lambd": 0.001, "block_size": 1, "stepsize": 12, - "depth": 1 + "depth": 1, + "parallel_steps": 128 } diff --git a/experiment_configs/repeats/diagonal_linear_ncde/EthanolConcentration.json b/experiment_configs/repeats/diagonal_linear_ncde/EthanolConcentration.json index 9a71a45..ec48430 100644 --- a/experiment_configs/repeats/diagonal_linear_ncde/EthanolConcentration.json +++ b/experiment_configs/repeats/diagonal_linear_ncde/EthanolConcentration.json @@ -26,5 +26,6 @@ "block_size": 1, "depth": 1, "stepsize": 1, - "lambd": 0.000001 + "lambd": 0.000001, + "parallel_steps": 128 } diff --git a/experiment_configs/repeats/diagonal_linear_ncde/Heartbeat.json b/experiment_configs/repeats/diagonal_linear_ncde/Heartbeat.json index ff81f81..b79b9f0 100644 --- a/experiment_configs/repeats/diagonal_linear_ncde/Heartbeat.json +++ b/experiment_configs/repeats/diagonal_linear_ncde/Heartbeat.json @@ -26,5 +26,6 @@ "block_size": 1, "depth": 1, "stepsize": 2, - "lambd": 0.000001 + "lambd": 0.000001, + "parallel_steps": 128 } diff --git a/experiment_configs/repeats/diagonal_linear_ncde/MotorImagery.json b/experiment_configs/repeats/diagonal_linear_ncde/MotorImagery.json index 76ca26e..d9985a5 100644 --- a/experiment_configs/repeats/diagonal_linear_ncde/MotorImagery.json +++ b/experiment_configs/repeats/diagonal_linear_ncde/MotorImagery.json @@ -26,5 +26,6 @@ "block_size": 1, "depth": 1, "stepsize": 16, - "lambd": 0.001 + "lambd": 0.001, + "parallel_steps": 128 } diff --git a/experiment_configs/repeats/diagonal_linear_ncde/SelfRegulationSCP1.json b/experiment_configs/repeats/diagonal_linear_ncde/SelfRegulationSCP1.json index e60a2c4..09e5246 100644 --- a/experiment_configs/repeats/diagonal_linear_ncde/SelfRegulationSCP1.json +++ b/experiment_configs/repeats/diagonal_linear_ncde/SelfRegulationSCP1.json @@ -26,5 +26,6 @@ "block_size": 1, "stepsize": 16, "depth": 1, - "lambd": 0.0 + "lambd": 0.0, + "parallel_steps": 128 } diff --git a/experiment_configs/repeats/diagonal_linear_ncde/SelfRegulationSCP2.json b/experiment_configs/repeats/diagonal_linear_ncde/SelfRegulationSCP2.json index ec72948..da05bf3 100644 --- a/experiment_configs/repeats/diagonal_linear_ncde/SelfRegulationSCP2.json +++ b/experiment_configs/repeats/diagonal_linear_ncde/SelfRegulationSCP2.json @@ -26,5 +26,6 @@ "block_size": 1, "stepsize": 4, "depth": 1, - "lambd": 0.001 + "lambd": 0.001, + "parallel_steps": 128 } diff --git a/experiment_configs/repeats/dplr_linear_ncde/EigenWorms.json b/experiment_configs/repeats/dplr_linear_ncde/EigenWorms.json new file mode 100644 index 0000000..108d2b9 --- /dev/null +++ b/experiment_configs/repeats/dplr_linear_ncde/EigenWorms.json @@ -0,0 +1,35 @@ +{ + "seeds": [ + 2345, + 3456, + 4567, + 5678, + 6789 + ], + "data_dir": "data_dir", + "output_parent_dir": "", + "lr_scheduler": "lambda lr: lr", + "num_steps": 100000, + "print_steps": 1000, + "early_stopping_steps": 10, + "batch_size": 32, + "model_name": "linear_ncde", + "metric": "accuracy", + "classification": true, + "dataset_name": "EigenWorms", + "use_presplit": false, + "T": 1, + "scale": 1, + "time": "True", + "lr": "0.001", + "hidden_dim": "128", + "lambd": 0.001, + "block_size": 1, + "stepsize": 12, + "depth": 2, + "parallel_steps": 128, + "walsh_hadamard": false, + "diagonal_dense": false, + "sparsity": 1.0, + "rank": 4 +} diff --git a/experiment_configs/repeats/dplr_linear_ncde/EthanolConcentration.json b/experiment_configs/repeats/dplr_linear_ncde/EthanolConcentration.json new file mode 100644 index 0000000..3f0aff0 --- /dev/null +++ b/experiment_configs/repeats/dplr_linear_ncde/EthanolConcentration.json @@ -0,0 +1,35 @@ +{ + "seeds": [ + 2345, + 3456, + 4567, + 5678, + 6789 + ], + "data_dir": "data_dir", + "output_parent_dir": "", + "lr_scheduler": "lambda lr: lr", + "num_steps": 100000, + "print_steps": 1000, + "early_stopping_steps": 10, + "batch_size": 32, + "model_name": "linear_ncde", + "metric": "accuracy", + "classification": true, + "dataset_name": "EthanolConcentration", + "use_presplit": false, + "T": 1, + "scale": 1, + "time": "True", + "lr": "0.0001", + "hidden_dim": "64", + "block_size": 1, + "depth": 1, + "stepsize": 1, + "lambd": 0.000001, + "parallel_steps": 128, + "walsh_hadamard": false, + "diagonal_dense": false, + "sparsity": 1.0, + "rank": 4 +} diff --git a/experiment_configs/repeats/dplr_linear_ncde/Heartbeat.json b/experiment_configs/repeats/dplr_linear_ncde/Heartbeat.json new file mode 100644 index 0000000..288470c --- /dev/null +++ b/experiment_configs/repeats/dplr_linear_ncde/Heartbeat.json @@ -0,0 +1,35 @@ +{ + "seeds": [ + 2345, + 3456, + 4567, + 5678, + 6789 + ], + "data_dir": "data_dir", + "output_parent_dir": "", + "lr_scheduler": "lambda lr: lr", + "num_steps": 100000, + "print_steps": 1000, + "early_stopping_steps": 10, + "batch_size": 32, + "model_name": "linear_ncde", + "metric": "accuracy", + "classification": true, + "dataset_name": "Heartbeat", + "use_presplit": false, + "T": 1, + "scale": 1, + "time": "True", + "lr": "0.001", + "hidden_dim": "16", + "block_size": 1, + "depth": 2, + "stepsize": 2, + "lambd": 0.000001, + "parallel_steps": 128, + "walsh_hadamard": false, + "diagonal_dense": false, + "sparsity": 1.0, + "rank": 4 +} diff --git a/experiment_configs/repeats/dplr_linear_ncde/MotorImagery.json b/experiment_configs/repeats/dplr_linear_ncde/MotorImagery.json new file mode 100644 index 0000000..2b661fe --- /dev/null +++ b/experiment_configs/repeats/dplr_linear_ncde/MotorImagery.json @@ -0,0 +1,35 @@ +{ + "seeds": [ + 2345, + 3456, + 4567, + 5678, + 6789 + ], + "data_dir": "data_dir", + "output_parent_dir": "", + "lr_scheduler": "lambda lr: lr", + "num_steps": 100000, + "print_steps": 1000, + "early_stopping_steps": 10, + "batch_size": 32, + "model_name": "linear_ncde", + "metric": "accuracy", + "classification": true, + "dataset_name": "MotorImagery", + "use_presplit": false, + "T": 1, + "scale": 1, + "time": "False", + "lr": "0.001", + "hidden_dim": "16", + "block_size": 1, + "depth": 2, + "stepsize": 16, + "lambd": 0.001, + "parallel_steps": 128, + "walsh_hadamard": false, + "diagonal_dense": false, + "sparsity": 1.0, + "rank": 4 +} diff --git a/experiment_configs/repeats/dplr_linear_ncde/SelfRegulationSCP1.json b/experiment_configs/repeats/dplr_linear_ncde/SelfRegulationSCP1.json new file mode 100644 index 0000000..0e4fd19 --- /dev/null +++ b/experiment_configs/repeats/dplr_linear_ncde/SelfRegulationSCP1.json @@ -0,0 +1,35 @@ +{ + "seeds": [ + 2345, + 3456, + 4567, + 5678, + 6789 + ], + "data_dir": "data_dir", + "output_parent_dir": "", + "lr_scheduler": "lambda lr: lr", + "num_steps": 100000, + "print_steps": 1000, + "early_stopping_steps": 10, + "batch_size": 32, + "model_name": "linear_ncde", + "metric": "accuracy", + "classification": true, + "dataset_name": "SelfRegulationSCP1", + "use_presplit": false, + "T": 1, + "scale": 1, + "time": "False", + "lr": "0.0001", + "hidden_dim": "64", + "block_size": 1, + "stepsize": 16, + "depth": 2, + "lambd": 0.0, + "parallel_steps": 128, + "walsh_hadamard": false, + "diagonal_dense": false, + "sparsity": 1.0, + "rank": 4 +} diff --git a/experiment_configs/repeats/dplr_linear_ncde/SelfRegulationSCP2.json b/experiment_configs/repeats/dplr_linear_ncde/SelfRegulationSCP2.json new file mode 100644 index 0000000..2b37fb5 --- /dev/null +++ b/experiment_configs/repeats/dplr_linear_ncde/SelfRegulationSCP2.json @@ -0,0 +1,35 @@ +{ + "seeds": [ + 2345, + 3456, + 4567, + 5678, + 6789 + ], + "data_dir": "data_dir", + "output_parent_dir": "", + "lr_scheduler": "lambda lr: lr", + "num_steps": 100000, + "print_steps": 1000, + "early_stopping_steps": 10, + "batch_size": 32, + "model_name": "linear_ncde", + "metric": "accuracy", + "classification": true, + "dataset_name": "SelfRegulationSCP2", + "use_presplit": false, + "T": 1, + "scale": 1, + "time": "False", + "lr": "0.0001", + "hidden_dim": "128", + "block_size": 1, + "stepsize": 4, + "depth": 2, + "lambd": 0.001, + "parallel_steps": 128, + "walsh_hadamard": false, + "diagonal_dense": false, + "sparsity": 1.0, + "rank": 4 +} diff --git a/experiment_configs/repeats/ncde/EigenWorms.json b/experiment_configs/repeats/ncde/EigenWorms.json index 0e0672f..7701426 100644 --- a/experiment_configs/repeats/ncde/EigenWorms.json +++ b/experiment_configs/repeats/ncde/EigenWorms.json @@ -26,4 +26,4 @@ "hidden_dim": "128", "vf_depth": "3", "vf_width": "128" -} \ No newline at end of file +} diff --git a/experiment_configs/repeats/sparse_linear_ncde/EigenWorms.json b/experiment_configs/repeats/sparse_linear_ncde/EigenWorms.json new file mode 100644 index 0000000..5c2cc40 --- /dev/null +++ b/experiment_configs/repeats/sparse_linear_ncde/EigenWorms.json @@ -0,0 +1,35 @@ +{ + "seeds": [ + 2345, + 3456, + 4567, + 5678, + 6789 + ], + "data_dir": "data_dir", + "output_parent_dir": "", + "lr_scheduler": "lambda lr: lr", + "num_steps": 100000, + "print_steps": 1000, + "early_stopping_steps": 10, + "batch_size": 32, + "model_name": "linear_ncde", + "metric": "accuracy", + "classification": true, + "dataset_name": "EigenWorms", + "use_presplit": false, + "T": 1, + "scale": 1, + "time": "True", + "lr": "0.001", + "hidden_dim": "128", + "lambd": 0.001, + "block_size": 1, + "stepsize": 12, + "depth": 2, + "parallel_steps": 128, + "walsh_hadamard": false, + "diagonal_dense": false, + "sparsity": 0.1, + "rank": 0 +} diff --git a/experiment_configs/repeats/sparse_linear_ncde/EthanolConcentration.json b/experiment_configs/repeats/sparse_linear_ncde/EthanolConcentration.json new file mode 100644 index 0000000..6935a7c --- /dev/null +++ b/experiment_configs/repeats/sparse_linear_ncde/EthanolConcentration.json @@ -0,0 +1,35 @@ +{ + "seeds": [ + 2345, + 3456, + 4567, + 5678, + 6789 + ], + "data_dir": "data_dir", + "output_parent_dir": "", + "lr_scheduler": "lambda lr: lr", + "num_steps": 100000, + "print_steps": 1000, + "early_stopping_steps": 10, + "batch_size": 32, + "model_name": "linear_ncde", + "metric": "accuracy", + "classification": true, + "dataset_name": "EthanolConcentration", + "use_presplit": false, + "T": 1, + "scale": 1, + "time": "True", + "lr": "0.0001", + "hidden_dim": "64", + "block_size": 1, + "depth": 1, + "stepsize": 1, + "lambd": 0.000001, + "parallel_steps": 128, + "walsh_hadamard": false, + "diagonal_dense": false, + "sparsity": 0.1, + "rank": 0 +} diff --git a/experiment_configs/repeats/sparse_linear_ncde/Heartbeat.json b/experiment_configs/repeats/sparse_linear_ncde/Heartbeat.json new file mode 100644 index 0000000..5de2ffa --- /dev/null +++ b/experiment_configs/repeats/sparse_linear_ncde/Heartbeat.json @@ -0,0 +1,35 @@ +{ + "seeds": [ + 2345, + 3456, + 4567, + 5678, + 6789 + ], + "data_dir": "data_dir", + "output_parent_dir": "", + "lr_scheduler": "lambda lr: lr", + "num_steps": 100000, + "print_steps": 1000, + "early_stopping_steps": 10, + "batch_size": 32, + "model_name": "linear_ncde", + "metric": "accuracy", + "classification": true, + "dataset_name": "Heartbeat", + "use_presplit": false, + "T": 1, + "scale": 1, + "time": "True", + "lr": "0.001", + "hidden_dim": "16", + "block_size": 1, + "depth": 2, + "stepsize": 2, + "lambd": 0.000001, + "parallel_steps": 128, + "walsh_hadamard": false, + "diagonal_dense": false, + "sparsity": 0.1, + "rank": 0 +} diff --git a/experiment_configs/repeats/sparse_linear_ncde/MotorImagery.json b/experiment_configs/repeats/sparse_linear_ncde/MotorImagery.json new file mode 100644 index 0000000..37b4b24 --- /dev/null +++ b/experiment_configs/repeats/sparse_linear_ncde/MotorImagery.json @@ -0,0 +1,35 @@ +{ + "seeds": [ + 2345, + 3456, + 4567, + 5678, + 6789 + ], + "data_dir": "data_dir", + "output_parent_dir": "", + "lr_scheduler": "lambda lr: lr", + "num_steps": 100000, + "print_steps": 1000, + "early_stopping_steps": 10, + "batch_size": 32, + "model_name": "linear_ncde", + "metric": "accuracy", + "classification": true, + "dataset_name": "MotorImagery", + "use_presplit": false, + "T": 1, + "scale": 1, + "time": "False", + "lr": "0.001", + "hidden_dim": "16", + "block_size": 1, + "depth": 2, + "stepsize": 16, + "lambd": 0.001, + "parallel_steps": 128, + "walsh_hadamard": false, + "diagonal_dense": false, + "sparsity": 0.1, + "rank": 0 +} diff --git a/experiment_configs/repeats/sparse_linear_ncde/SelfRegulationSCP1.json b/experiment_configs/repeats/sparse_linear_ncde/SelfRegulationSCP1.json new file mode 100644 index 0000000..1286eeb --- /dev/null +++ b/experiment_configs/repeats/sparse_linear_ncde/SelfRegulationSCP1.json @@ -0,0 +1,35 @@ +{ + "seeds": [ + 2345, + 3456, + 4567, + 5678, + 6789 + ], + "data_dir": "data_dir", + "output_parent_dir": "", + "lr_scheduler": "lambda lr: lr", + "num_steps": 100000, + "print_steps": 1000, + "early_stopping_steps": 10, + "batch_size": 32, + "model_name": "linear_ncde", + "metric": "accuracy", + "classification": true, + "dataset_name": "SelfRegulationSCP1", + "use_presplit": false, + "T": 1, + "scale": 1, + "time": "False", + "lr": "0.0001", + "hidden_dim": "64", + "block_size": 1, + "stepsize": 16, + "depth": 2, + "lambd": 0.0, + "parallel_steps": 128, + "walsh_hadamard": false, + "diagonal_dense": false, + "sparsity": 0.1, + "rank": 0 +} diff --git a/experiment_configs/repeats/sparse_linear_ncde/SelfRegulationSCP2.json b/experiment_configs/repeats/sparse_linear_ncde/SelfRegulationSCP2.json new file mode 100644 index 0000000..2ca7d5c --- /dev/null +++ b/experiment_configs/repeats/sparse_linear_ncde/SelfRegulationSCP2.json @@ -0,0 +1,35 @@ +{ + "seeds": [ + 2345, + 3456, + 4567, + 5678, + 6789 + ], + "data_dir": "data_dir", + "output_parent_dir": "", + "lr_scheduler": "lambda lr: lr", + "num_steps": 100000, + "print_steps": 1000, + "early_stopping_steps": 10, + "batch_size": 32, + "model_name": "linear_ncde", + "metric": "accuracy", + "classification": true, + "dataset_name": "SelfRegulationSCP2", + "use_presplit": false, + "T": 1, + "scale": 1, + "time": "False", + "lr": "0.0001", + "hidden_dim": "128", + "block_size": 1, + "stepsize": 4, + "depth": 2, + "lambd": 0.001, + "parallel_steps": 128, + "walsh_hadamard": false, + "diagonal_dense": false, + "sparsity": 0.1, + "rank": 0 +} diff --git a/experiment_configs/repeats/wh_linear_ncde/EigenWorms.json b/experiment_configs/repeats/wh_linear_ncde/EigenWorms.json new file mode 100644 index 0000000..29faeb1 --- /dev/null +++ b/experiment_configs/repeats/wh_linear_ncde/EigenWorms.json @@ -0,0 +1,35 @@ +{ + "seeds": [ + 2345, + 3456, + 4567, + 5678, + 6789 + ], + "data_dir": "data_dir", + "output_parent_dir": "", + "lr_scheduler": "lambda lr: lr", + "num_steps": 100000, + "print_steps": 1000, + "early_stopping_steps": 10, + "batch_size": 32, + "model_name": "linear_ncde", + "metric": "accuracy", + "classification": true, + "dataset_name": "EigenWorms", + "use_presplit": false, + "T": 1, + "scale": 1, + "time": "True", + "lr": "0.001", + "hidden_dim": "128", + "lambd": 0.001, + "block_size": 1, + "stepsize": 12, + "depth": 2, + "parallel_steps": 128, + "walsh_hadamard": true, + "diagonal_dense": false, + "sparsity": 1.0, + "rank": 0 +} diff --git a/experiment_configs/repeats/wh_linear_ncde/EthanolConcentration.json b/experiment_configs/repeats/wh_linear_ncde/EthanolConcentration.json new file mode 100644 index 0000000..207c8f0 --- /dev/null +++ b/experiment_configs/repeats/wh_linear_ncde/EthanolConcentration.json @@ -0,0 +1,35 @@ +{ + "seeds": [ + 2345, + 3456, + 4567, + 5678, + 6789 + ], + "data_dir": "data_dir", + "output_parent_dir": "", + "lr_scheduler": "lambda lr: lr", + "num_steps": 100000, + "print_steps": 1000, + "early_stopping_steps": 10, + "batch_size": 32, + "model_name": "linear_ncde", + "metric": "accuracy", + "classification": true, + "dataset_name": "EthanolConcentration", + "use_presplit": false, + "T": 1, + "scale": 1, + "time": "True", + "lr": "0.0001", + "hidden_dim": "64", + "block_size": 1, + "depth": 1, + "stepsize": 1, + "lambd": 0.000001, + "parallel_steps": 128, + "walsh_hadamard": true, + "diagonal_dense": false, + "sparsity": 1.0, + "rank": 0 +} diff --git a/experiment_configs/repeats/wh_linear_ncde/Heartbeat.json b/experiment_configs/repeats/wh_linear_ncde/Heartbeat.json new file mode 100644 index 0000000..bd88bc3 --- /dev/null +++ b/experiment_configs/repeats/wh_linear_ncde/Heartbeat.json @@ -0,0 +1,35 @@ +{ + "seeds": [ + 2345, + 3456, + 4567, + 5678, + 6789 + ], + "data_dir": "data_dir", + "output_parent_dir": "", + "lr_scheduler": "lambda lr: lr", + "num_steps": 100000, + "print_steps": 1000, + "early_stopping_steps": 10, + "batch_size": 32, + "model_name": "linear_ncde", + "metric": "accuracy", + "classification": true, + "dataset_name": "Heartbeat", + "use_presplit": false, + "T": 1, + "scale": 1, + "time": "True", + "lr": "0.001", + "hidden_dim": "16", + "block_size": 1, + "depth": 2, + "stepsize": 2, + "lambd": 0.000001, + "parallel_steps": 128, + "walsh_hadamard": true, + "diagonal_dense": false, + "sparsity": 1.0, + "rank": 0 +} diff --git a/experiment_configs/repeats/wh_linear_ncde/MotorImagery.json b/experiment_configs/repeats/wh_linear_ncde/MotorImagery.json new file mode 100644 index 0000000..d936682 --- /dev/null +++ b/experiment_configs/repeats/wh_linear_ncde/MotorImagery.json @@ -0,0 +1,35 @@ +{ + "seeds": [ + 2345, + 3456, + 4567, + 5678, + 6789 + ], + "data_dir": "data_dir", + "output_parent_dir": "", + "lr_scheduler": "lambda lr: lr", + "num_steps": 100000, + "print_steps": 1000, + "early_stopping_steps": 10, + "batch_size": 32, + "model_name": "linear_ncde", + "metric": "accuracy", + "classification": true, + "dataset_name": "MotorImagery", + "use_presplit": false, + "T": 1, + "scale": 1, + "time": "False", + "lr": "0.001", + "hidden_dim": "16", + "block_size": 1, + "depth": 2, + "stepsize": 16, + "lambd": 0.001, + "parallel_steps": 128, + "walsh_hadamard": true, + "diagonal_dense": false, + "sparsity": 1.0, + "rank": 0 +} diff --git a/experiment_configs/repeats/wh_linear_ncde/SelfRegulationSCP1.json b/experiment_configs/repeats/wh_linear_ncde/SelfRegulationSCP1.json new file mode 100644 index 0000000..2bd022c --- /dev/null +++ b/experiment_configs/repeats/wh_linear_ncde/SelfRegulationSCP1.json @@ -0,0 +1,35 @@ +{ + "seeds": [ + 2345, + 3456, + 4567, + 5678, + 6789 + ], + "data_dir": "data_dir", + "output_parent_dir": "", + "lr_scheduler": "lambda lr: lr", + "num_steps": 100000, + "print_steps": 1000, + "early_stopping_steps": 10, + "batch_size": 32, + "model_name": "linear_ncde", + "metric": "accuracy", + "classification": true, + "dataset_name": "SelfRegulationSCP1", + "use_presplit": false, + "T": 1, + "scale": 1, + "time": "False", + "lr": "0.0001", + "hidden_dim": "64", + "block_size": 1, + "stepsize": 16, + "depth": 2, + "lambd": 0.0, + "parallel_steps": 128, + "walsh_hadamard": true, + "diagonal_dense": false, + "sparsity": 1.0, + "rank": 0 +} diff --git a/experiment_configs/repeats/wh_linear_ncde/SelfRegulationSCP2.json b/experiment_configs/repeats/wh_linear_ncde/SelfRegulationSCP2.json new file mode 100644 index 0000000..bd4cd62 --- /dev/null +++ b/experiment_configs/repeats/wh_linear_ncde/SelfRegulationSCP2.json @@ -0,0 +1,35 @@ +{ + "seeds": [ + 2345, + 3456, + 4567, + 5678, + 6789 + ], + "data_dir": "data_dir", + "output_parent_dir": "", + "lr_scheduler": "lambda lr: lr", + "num_steps": 100000, + "print_steps": 1000, + "early_stopping_steps": 10, + "batch_size": 32, + "model_name": "linear_ncde", + "metric": "accuracy", + "classification": true, + "dataset_name": "SelfRegulationSCP2", + "use_presplit": false, + "T": 1, + "scale": 1, + "time": "False", + "lr": "0.0001", + "hidden_dim": "128", + "block_size": 1, + "stepsize": 4, + "depth": 2, + "lambd": 0.001, + "parallel_steps": 128, + "walsh_hadamard": true, + "diagonal_dense": false, + "sparsity": 1.0, + "rank": 0 +} diff --git a/models/LinearNeuralCDEs.py b/models/LinearNeuralCDEs.py index 1f9f7ee..14eb9cb 100644 --- a/models/LinearNeuralCDEs.py +++ b/models/LinearNeuralCDEs.py @@ -25,13 +25,15 @@ from __future__ import annotations -from typing import List, Tuple +from typing import List, Optional, Tuple import equinox as eqx import jax import jax.numpy as jnp import jax.random as jr import roughpy as rp +from jax.experimental.sparse import random_bcoo +from scipy.linalg import hadamard def to_tuple(el): @@ -55,7 +57,6 @@ def depth(b): class LogLinearCDE(eqx.Module): init_layer: eqx.nn.Linear out_layer: eqx.nn.Linear - vf_A: jnp.ndarray hidden_dim: int block_size: int num_blocks: int @@ -65,7 +66,19 @@ class LogLinearCDE(eqx.Module): lambd: float w_init_std: float classification: bool - + walsh_hadamard: bool + diagonal_dense: bool + sparsity: float + rank: int + + vf_A: Optional[jnp.ndarray] = None + hadamard_matrix: Optional[jnp.ndarray] = None + vf_A_sparse: Optional[jnp.ndarray] = None + vf_A_diag: Optional[jnp.ndarray] = None + vf_A_dense: Optional[jnp.ndarray] = None + vf_A_u: Optional[jnp.ndarray] = None + vf_A_v: Optional[jnp.ndarray] = None + dense_size: int = 0 lip2: bool = True nondeterministic: bool = False stateful: bool = False @@ -79,9 +92,13 @@ def __init__( block_size: int, logsig_depth: int, lambd: float = 1.0, + walsh_hadamard: bool = False, w_init_std: float = 0.25, parallel_steps: int = 128, classification: bool = True, + diagonal_dense: bool = False, + rank: int = 0, + sparsity: float = 1.0, key, ): if hidden_dim % block_size != 0: @@ -104,13 +121,74 @@ def __init__( self.init_layer = eqx.nn.Linear(data_dim, hidden_dim, key=k_init) self.out_layer = eqx.nn.Linear(hidden_dim, label_dim, key=k_B) - self.vf_A = ( - jr.normal(k_A, (data_dim + 1, self.num_blocks * block_size * block_size)) - * self.w_init_std - / jnp.sqrt(block_size) - ) + if diagonal_dense: + k_A_diag, k_A_dense = jr.split(k_A, 2) + self.vf_A_diag = ( + jr.normal(k_A_diag, (data_dim, self.hidden_dim - self.block_size)) + * self.w_init_std + ) + self.vf_A_dense = ( + jr.normal(k_A_dense, (data_dim, block_size, block_size)) + * self.w_init_std + / jnp.sqrt(block_size) + ) + self.dense_size = block_size + elif sparsity < 1.0: + total = data_dim * hidden_dim * hidden_dim + nnz = int(jnp.round(total * sparsity)) + if nnz == 0: + raise ValueError("sparsity too low, no weights left!") + + self.vf_A_sparse = ( + random_bcoo( + key=k_A, + shape=(data_dim, self.hidden_dim, self.hidden_dim), + nse=nnz, + generator=jax.random.normal, + dtype=jnp.float32, + ) + * self.w_init_std + / jnp.sqrt(self.hidden_dim) + ) + self.block_size = self.hidden_dim + self.num_blocks = 1 + else: + self.vf_A = ( + jr.normal(k_A, (data_dim, self.num_blocks * block_size * block_size)) + * self.w_init_std + / jnp.sqrt(block_size) + ) + if rank > 0: + k_A_u, k_A_v = jr.split(k_A, 2) + self.vf_A_u = ( + jr.normal(k_A_u, (data_dim, self.hidden_dim, rank)) + * self.w_init_std + / jnp.sqrt(rank) + ) + self.vf_A_v = ( + jr.normal(k_A_v, (data_dim, self.hidden_dim, rank)) + * self.w_init_std + / jnp.sqrt(rank) + ) + self.block_size = self.hidden_dim + self.num_blocks = 1 + self.classification = classification + self.walsh_hadamard = walsh_hadamard + if self.walsh_hadamard: + hadamard_matrix = hadamard(self.hidden_dim) + self.hadamard_matrix = jnp.array( + hadamard_matrix, dtype=jnp.float32 + ) / jnp.sqrt(self.hidden_dim) + self.block_size = self.hidden_dim + self.num_blocks = 1 + else: + self.hadamard_matrix = None + self.diagonal_dense = diagonal_dense + self.sparsity = sparsity + self.rank = rank + def log_ode(self, vf): basis_index = {} @@ -155,58 +233,159 @@ def log_ode(self, vf): def __call__(self, X): ts, logsigs, x0 = X - y0 = self.init_layer(x0) - vfs = self.vf_A.reshape(-1, self.num_blocks, self.block_size, self.block_size) - lie_brackets = jax.vmap(self.log_ode, in_axes=(1))(vfs) - log_flows = jnp.einsum("ijkl,ml->mijk", lie_brackets, logsigs[:, 1:]) - flows = log_flows + jnp.eye(self.block_size)[None, None, :, :] + # Each branch prepares `flows` and `step`/`parallel_step` functions + # for the generic scanner loop at the end. - def step(y, flow): - y_block = y.reshape(self.num_blocks, self.block_size, 1) - y_next = flow @ y_block - y_next = y_next.reshape( - self.hidden_dim, - ) - return y_next, y_next + if self.walsh_hadamard and self.parallel_steps == 1 and self.logsig_depth == 1: + flows = logsigs[:, 1:] @ self.vf_A + + def step(y, flow): + # flowed = fwht(flow * y) + flowed = self.hadamard_matrix @ (flow * y) + y_next = y + flowed + return y_next, y_next - def parallel_step(y, flows): - compose = lambda a, b: jnp.matmul(b, a) - flow_total = jax.lax.associative_scan(compose, flows) - y_block = y.reshape(self.num_blocks, self.block_size, 1) - y_new = jnp.matmul(flow_total, y_block).reshape(-1, self.hidden_dim) - return y_new[-1], y_new + parallel_step = None - if self.parallel_steps == 1: + elif self.rank > 0 and self.logsig_depth == 1 and self.parallel_steps == 1: + a_seq = logsigs[:, 1:] # (T-1, C) + + def step(y, a): # a: (C,) + diag = (a @ self.vf_A) * y # (H,) + vTy = jnp.einsum("chr,h->cr", self.vf_A_v, y) # (C, R), V_c^T y + lowrank = jnp.einsum("chr,cr->h", self.vf_A_u, a[:, None] * vTy) # (H,) + y_next = y + diag + lowrank + return y_next, y_next + + parallel_step = None + flows = a_seq + + elif self.diagonal_dense: + diag_size = self.hidden_dim - self.dense_size + + # Calculate flows for both parts + num_log_sig_coeffs = self.vf_A_diag.shape[0] + update_diag = logsigs[:, 1 : num_log_sig_coeffs + 1] @ self.vf_A_diag + flows_diag = 1 + update_diag + + lie_brackets_dense = self.log_ode(self.vf_A_dense) + log_flows_dense = jnp.einsum( + "jkl,ml->mjk", lie_brackets_dense, logsigs[:, 1:] + ) + flows_dense = log_flows_dense + jnp.eye(self.dense_size)[None, :, :] + flows = (flows_diag, flows_dense) + + def step(y, flow_slice): + flow_diag, flow_dense = flow_slice + y_diag, y_dense = y[:diag_size], y[diag_size:] + y_next_diag = y_diag * flow_diag + y_next_dense = flow_dense @ y_dense + y_next = jnp.concatenate([y_next_diag, y_next_dense]) + return y_next, y_next + + def parallel_step_comp(flow1, flow2): + flow1_diag, flow1_dense = flow1 + flow2_diag, flow2_dense = flow2 + return (flow1_diag * flow2_diag, flow2_dense @ flow1_dense) + + def parallel_step(y, flows_slice): + y_diag, y_dense = y[:diag_size], y[diag_size:] + total_flows = jax.lax.associative_scan(parallel_step_comp, flows_slice) + total_flows_diag, total_flows_dense = total_flows + ys_diag_new = y_diag * total_flows_diag + ys_dense_new = jnp.einsum("kij,j->ki", total_flows_dense, y_dense) + ys_new = jnp.concatenate([ys_diag_new, ys_dense_new], axis=-1) + return ys_new[-1], ys_new + + elif self.block_size == 1 and self.rank == 0 and not self.walsh_hadamard: + num_log_sig_coeffs = self.vf_A.shape[0] + updates = logsigs[:, 1 : num_log_sig_coeffs + 1] @ self.vf_A + flows = 1 + updates + + def step(y, flow): + return y * flow, y * flow + + def parallel_step_comp(f1, f2): + return f1 * f2 + + def parallel_step(y, flows_slice): + total_flows = jax.lax.associative_scan(parallel_step_comp, flows_slice) + ys_new = y * total_flows + return ys_new[-1], ys_new + + else: # Generic case for block_size > 1 + if self.sparsity < 1.0: + vfs = self.vf_A_sparse.todense().reshape( + -1, 1, self.hidden_dim, self.hidden_dim + ) + elif self.rank > 0: + low_rank = jnp.einsum("cir,cjr->cij", self.vf_A_u, self.vf_A_v) + diags = jax.vmap(jnp.diag)(self.vf_A) + vfs = (low_rank + diags)[:, None, :, :] + elif self.walsh_hadamard: + vfs = self.vf_A[:, None, :] * self.hadamard_matrix[None, :, :] + vfs = jnp.reshape(vfs, (-1, 1, self.hidden_dim, self.hidden_dim)) + else: + vfs = self.vf_A.reshape( + -1, self.num_blocks, self.block_size, self.block_size + ) + + lie_brackets = jax.vmap(self.log_ode, in_axes=(1))(vfs) + log_flows = jnp.einsum("ijkl,ml->mijk", lie_brackets, logsigs[:, 1:]) + flows = log_flows + jnp.eye(self.block_size)[None, None, :, :] + + step_comp = lambda x, y: x @ y + parallel_step_comp = lambda x, y: jnp.matmul(y, x) + + def step(y, flow): + y_block = y.reshape(self.num_blocks, self.block_size, 1) + y_next = step_comp(flow, y_block).reshape( + self.hidden_dim, + ) + return y_next, y_next + + def parallel_step(y, flows): + flow_total = jax.lax.associative_scan(parallel_step_comp, flows) + y_block = y.reshape(self.num_blocks, self.block_size, 1) + y_new = jnp.matmul(flow_total, y_block).reshape(-1, self.hidden_dim) + return y_new[-1], y_new + + # --- Generic scanner logic --- + if self.parallel_steps == 1 or parallel_step is None: scan_fn = step + scan_inp = jax.tree_util.tree_map(lambda x: x[1:], flows) remainder = 0 - scan_inp = flows else: scan_fn = parallel_step - t = len(flows) + t = jax.tree_util.tree_leaves(flows)[0].shape[0] remainder = (t - 1) % self.parallel_steps - core = flows[1:] if remainder == 0 else flows[1:-remainder] - scan_inp = jnp.reshape( - core, - ( - -1, - self.parallel_steps, - self.num_blocks, - self.block_size, - self.block_size, - ), + + if remainder == 0: + core_flows = jax.tree_util.tree_map(lambda x: x[1:], flows) + else: + core_flows = jax.tree_util.tree_map(lambda x: x[1:-remainder], flows) + + scan_inp = jax.tree_util.tree_map( + lambda x: x.reshape(-1, self.parallel_steps, *x.shape[1:]), core_flows ) - _, ys = jax.lax.scan(scan_fn, y0, scan_inp) # (T‑1, H) - if len(ys.shape) == 3: - ys = jnp.reshape(ys, (-1, self.hidden_dim)) + _, ys = jax.lax.scan(scan_fn, y0, scan_inp) + + if not ( + self.parallel_steps == 1 or parallel_step is None + ): # Unpack parallel results + ys = ys.reshape(-1, self.hidden_dim) + ys = jnp.vstack([y0, ys]) + if remainder != 0: - inp_rem = flows[-remainder:] - _, y_rem = jax.lax.scan(step, ys[-1], inp_rem) + rem_flows = jax.tree_util.tree_map(lambda x: x[-remainder:], flows) + _, y_rem = jax.lax.scan(step, ys[-1], rem_flows) ys = jnp.vstack([ys, y_rem]) + # --- Final output layer --- if self.classification: ys = jnp.mean(ys, axis=0) preds = jax.nn.softmax(self.out_layer(ys)) diff --git a/models/generate_model.py b/models/generate_model.py index 02a8f9b..dcdc6be 100644 --- a/models/generate_model.py +++ b/models/generate_model.py @@ -73,6 +73,11 @@ def create_model( scale=1.0, lambd=0.0, w_init_std=0.25, + parallel_steps=1, + walsh_hadamard=False, + diagonal_dense=False, + sparsity=1.0, + rank=0, *, key, ): @@ -102,7 +107,7 @@ def create_model( ), None, ) - elif model_name in ["bd_linear_ncde", "diagonal_linear_ncde", "dense_linear_ncde"]: + elif model_name.endswith("_linear_ncde"): return ( LogLinearCDE( data_dim=data_dim, @@ -113,6 +118,11 @@ def create_model( lambd=lambd, w_init_std=w_init_std, classification=classification, + parallel_steps=parallel_steps, + walsh_hadamard=walsh_hadamard, + diagonal_dense=diagonal_dense, + sparsity=sparsity, + rank=rank, key=key, ), None, diff --git a/results/analyse_results.py b/results/analyse_results.py index ab3f0bd..493fa4e 100644 --- a/results/analyse_results.py +++ b/results/analyse_results.py @@ -16,103 +16,175 @@ """ import os +from collections import defaultdict +from typing import Dict, List import numpy as np -benchmark = "UEA" -experiment = "repeats" -results_dir = "results/paper_outputs/" + benchmark + "_outputs_" + experiment + "/" +def rank_scores(score_dict: Dict[str, float]) -> Dict[str, float]: + """Return the rank (1 = best) for each key in *score_dict*. + If two models obtain exactly the same score on a dataset they receive the + same rank; the next rank is offset accordingly (i.e. *dense* ranking / + competition ranking scheme). + """ + + # Sort by *descending* score because higher accuracy is better. + sorted_items = sorted(score_dict.items(), key=lambda kv: kv[1], reverse=True) + + ranks: Dict[str, float] = {} + current_rank = 1 + i = 0 + while i < len(sorted_items): + # Find block of items with identical score. + j = i + 1 + while j < len(sorted_items) and np.isclose( + sorted_items[j][1], sorted_items[i][1] + ): + j += 1 + + # All models in [i, j) share the same rank (dense/competition ranking). + for k in range(i, j): + model_name = sorted_items[k][0] + ranks[model_name] = current_rank + + current_rank += j - i # Dense ranking. + i = j + + return ranks + + +# ----------------------------------------------------------------------------- +# User‑configurable settings +# ----------------------------------------------------------------------------- + +benchmark = "UEA" # Either "UEA" or "PPG". +experiment = "repeats" # Either "hypopt" or "repeats". +results_dir = f"results/paper_outputs/{benchmark}_outputs_{experiment}/" + +# Determine optimisation direction. if benchmark == "UEA": best_idx = np.argmax best_val = max - operator = lambda x, y: x >= y + operator = lambda x, y: x >= y # noqa: E731 (keep as simple lambda) elif benchmark == "PPG": best_idx = np.argmin best_val = min - operator = lambda x, y: x <= y + operator = lambda x, y: x <= y # noqa: E731 else: raise ValueError(f"Unknown benchmark: {benchmark}") +# ----------------------------------------------------------------------------- +# Containers for summary statistics (used for *average* accuracy and *rank*) +# ----------------------------------------------------------------------------- + +model_to_dataset_scores: Dict[str, List[float]] = defaultdict(list) +# e.g. {"ncde": [74.0, 53.1, ...]} + +dataset_to_model_scores: Dict[str, Dict[str, float]] = defaultdict(dict) +# e.g. {"Heartbeat": {"ncde": 74.0, "mamba": 76.3, ...}} + +# ----------------------------------------------------------------------------- +# Main loop over all saved experiment results +# ----------------------------------------------------------------------------- + for model in sorted(os.listdir(results_dir)): - if os.path.isdir(results_dir + model): - model += "/" - for dataset in sorted(os.listdir(results_dir + model)): - if os.path.isdir(results_dir + model + dataset): - train_metrics = [] - val_metrics = [] - steps = [] - test_metrics = [] - exps = [] - dataset += "/" - for exp in os.listdir(results_dir + model + dataset): - if os.path.isdir(results_dir + model + dataset + exp): - if len(os.listdir(results_dir + model + dataset + exp)) != 0: - all_val_metric = np.load( - results_dir - + model - + dataset - + exp - + "/all_val_metric.npy" - ) - all_train_metric = np.load( - results_dir - + model - + dataset - + exp - + "/all_train_metric.npy" - ) - if benchmark == "PPG": - all_val_metric = all_val_metric[1:] - all_train_metric = all_train_metric[1:] - if experiment == "hypopt": - if operator( - all_train_metric[best_idx(all_val_metric)], - best_val(all_val_metric), - ): - exps.append(exp) - val_metrics.append(best_val(all_val_metric)) - train_metrics.append( - all_train_metric[best_idx(all_val_metric)] - ) - elif experiment == "repeats": - val_metrics.append( - np.load( - results_dir - + model - + dataset - + exp - + "/all_val_metric.npy" - ) - ) - test_metrics.append( - np.load( - results_dir - + model - + dataset - + exp - + "/test_metric.npy" - ) - ) - else: - raise ValueError(f"Unknown experiment: {experiment}") - if experiment == "hypopt": - val_metrics = np.array(val_metrics) - train_metrics = np.array(train_metrics) - idxs = np.where(val_metrics == best_val(val_metrics))[0] - train_idxs = np.where( - train_metrics[idxs] == best_val(train_metrics[idxs]) - )[0] - for tr_idx in train_idxs: - idx = idxs[tr_idx] - print( - f"{model[:-1]} {dataset[:-1]} {exps[idx]} {100 * val_metrics[idx]}" - ) - - elif experiment == "repeats": - test_metrics = np.array(test_metrics) - print( - f"{model[:-1]} {dataset[:-1]} {np.mean([len(x) for x in val_metrics])} " - f"{100 * np.mean(test_metrics)} {100 * np.std(test_metrics)}" - ) + if not os.path.isdir(os.path.join(results_dir, model)): + continue + + model_dir = os.path.join(results_dir, model) + for dataset in sorted(os.listdir(model_dir)): + dataset_dir = os.path.join(model_dir, dataset) + if not os.path.isdir(dataset_dir): + continue + + train_metrics = [] # Only used for *hypopt*. + val_metrics = [] + test_metrics = [] # Only used for *repeats*. + + for exp in os.listdir(dataset_dir): + exp_dir = os.path.join(dataset_dir, exp) + if not os.path.isdir(exp_dir): + continue + if not os.listdir(exp_dir): + continue # Empty directory – skip. + + all_val_metric = np.load(os.path.join(exp_dir, "all_val_metric.npy")) + all_train_metric = np.load(os.path.join(exp_dir, "all_train_metric.npy")) + + if benchmark == "PPG": # First element is burn‑in. + all_val_metric = all_val_metric[1:] + all_train_metric = all_train_metric[1:] + + if experiment == "hypopt": + if operator( + all_train_metric[best_idx(all_val_metric)], best_val(all_val_metric) + ): + val_metrics.append(best_val(all_val_metric)) + train_metrics.append(all_train_metric[best_idx(all_val_metric)]) + + elif experiment == "repeats": + val_metrics.append(all_val_metric) + test_metrics.append(np.load(os.path.join(exp_dir, "test_metric.npy"))) + else: + raise ValueError(f"Unknown experiment: {experiment}") + + # --------------------------------------------------------------------- + # Per‑dataset output + # --------------------------------------------------------------------- + if experiment == "hypopt": + if not val_metrics: # No valid experiments found. + continue + val_metrics = np.array(val_metrics) + train_metrics = np.array(train_metrics) + idxs = np.where(val_metrics == best_val(val_metrics))[0] + train_idxs = np.where(train_metrics[idxs] == best_val(train_metrics[idxs]))[ + 0 + ] + for tr_idx in train_idxs: + idx = idxs[tr_idx] + print(f"{model} {dataset} {exp} {100 * val_metrics[idx]:.4f}") + + elif experiment == "repeats": + if not test_metrics: # No runs – skip. + continue + test_metrics = np.array(test_metrics) + mean_test = 100 * np.mean(test_metrics) + std_test = 100 * np.std(test_metrics) + num_seeds = np.mean([len(x) for x in val_metrics]) # For completeness. + + print(f"{model} {dataset} {num_seeds:.1f} {mean_test:.8f} {std_test:.8f}") + + # Store for summary. + model_to_dataset_scores[model].append(mean_test) + dataset_to_model_scores[dataset][model] = mean_test + +# ----------------------------------------------------------------------------- +# Summary across datasets (only relevant for *repeats*) +# ----------------------------------------------------------------------------- + +if experiment == "repeats" and model_to_dataset_scores: + print("\n=== Summary across all datasets ===") + + # 1) Average test accuracy per model. + avg_test_accuracy = { + model: float(np.mean(scores)) + for model, scores in model_to_dataset_scores.items() + } + + # 2) Average rank per model. + model_ranks: Dict[str, List[int]] = defaultdict(list) + for dataset, scores in dataset_to_model_scores.items(): + ranks = rank_scores(scores) # dict {model: rank} + for mdl, rk in ranks.items(): + model_ranks[mdl].append(rk) + + avg_rank = {model: float(np.mean(ranks)) for model, ranks in model_ranks.items()} + + # Pretty print – sorted by average rank (ascending = better). + header = f"{'Model':<30s} {'Avg Test Acc (%)':>17s} {'Avg Rank':>10s}" + print(header) + print("-" * len(header)) + for mdl in sorted(avg_rank, key=lambda m: avg_rank[m]): + print(f"{mdl:<30s} {avg_test_accuracy[mdl]:>17.4f} {avg_rank[mdl]:>10.2f}") diff --git a/results/logsig_length.py b/results/logsig_length.py index 16e3154..021cc51 100644 --- a/results/logsig_length.py +++ b/results/logsig_length.py @@ -18,12 +18,12 @@ length1 = [iisig.logsiglength(v, 1) for v in vs] length2 = [iisig.logsiglength(v, 2) for v in vs] plt.figure(figsize=(8, 4)) -plt.plot(vs, vs, label="$v$", color="#377eb8", zorder=0, linewidth=3) +plt.plot(vs, vs, label="$d_X$", color="#377eb8", zorder=0, linewidth=3) plt.scatter(vs, length1, label="$N=1$", color="#ff7f00", s=100, zorder=1) plt.scatter(vs, length2, label="$N=2$", color="#4daf4a", s=100, zorder=2) -plt.xlabel("Time Series Dimension, $v$") +plt.xlabel("Time Series Dimension, $d_X$") plt.xticks(range(1, 16)) -plt.ylabel("Log-Signature Dimension, $\\beta(v,N)$") +plt.ylabel("Log-Signature Dimension, $\\beta(d_X,N)$") plt.title("Log-Signature Dimension vs Time Series Dimension") plt.legend() os.makedirs("results/images", exist_ok=True) diff --git a/results/memory_time_results.json b/results/memory_time_results.json index db6c913..c5736c2 100644 --- a/results/memory_time_results.json +++ b/results/memory_time_results.json @@ -1,166 +1,246 @@ { "memory": { "ncde": { - "EigenWorms": 2484, - "EthanolConcentration": 692, - "Heartbeat": 1462, - "MotorImagery": 4534, - "SelfRegulationSCP1": 694, - "SelfRegulationSCP2": 692 + "EigenWorms": 2687, + "EthanolConcentration": 895, + "Heartbeat": 1663, + "MotorImagery": 4735, + "SelfRegulationSCP1": 895, + "SelfRegulationSCP2": 895 }, "nrde": { - "EigenWorms": 2506, - "EthanolConcentration": 712, - "Heartbeat": 6860, - "MotorImagery": 4552, - "SelfRegulationSCP1": 716, - "SelfRegulationSCP2": 712 + "EigenWorms": 2689, + "EthanolConcentration": 895, + "Heartbeat": 7041, + "MotorImagery": 4735, + "SelfRegulationSCP1": 895, + "SelfRegulationSCP2": 895 }, "log_ncde": { - "EigenWorms": 2510, - "EthanolConcentration": 710, - "Heartbeat": 2774, - "MotorImagery": 4566, - "SelfRegulationSCP1": 724, - "SelfRegulationSCP2": 714 + "EigenWorms": 2689, + "EthanolConcentration": 895, + "Heartbeat": 2945, + "MotorImagery": 4737, + "SelfRegulationSCP1": 899, + "SelfRegulationSCP2": 899 }, "lru": { - "EigenWorms": 10716, - "EthanolConcentration": 1988, - "Heartbeat": 1466, - "MotorImagery": 8646, - "SelfRegulationSCP1": 960, - "SelfRegulationSCP2": 954 + "EigenWorms": 10881, + "EthanolConcentration": 2173, + "Heartbeat": 1663, + "MotorImagery": 8829, + "SelfRegulationSCP1": 1153, + "SelfRegulationSCP2": 1149 }, "S5": { - "EigenWorms": 6646, - "EthanolConcentration": 1520, - "Heartbeat": 1548, - "MotorImagery": 4616, - "SelfRegulationSCP1": 1798, - "SelfRegulationSCP2": 762 + "EigenWorms": 7039, + "EthanolConcentration": 2433, + "Heartbeat": 1919, + "MotorImagery": 4991, + "SelfRegulationSCP1": 2431, + "SelfRegulationSCP2": 1151 }, "mamba": { - "EigenWorms": 13486, - "EthanolConcentration": 4876, - "Heartbeat": 1650, - "MotorImagery": 3120, - "SelfRegulationSCP1": 1110, - "SelfRegulationSCP2": 2460 + "EigenWorms": 12239, + "EthanolConcentration": 5133, + "Heartbeat": 1979, + "MotorImagery": 3525, + "SelfRegulationSCP1": 1523, + "SelfRegulationSCP2": 2809 }, "S6": { - "EigenWorms": 7922, - "EthanolConcentration": 938, - "Heartbeat": 606, - "MotorImagery": 4056, - "SelfRegulationSCP1": 904, - "SelfRegulationSCP2": 1222 + "EigenWorms": 8235, + "EthanolConcentration": 1283, + "Heartbeat": 947, + "MotorImagery": 4397, + "SelfRegulationSCP1": 1203, + "SelfRegulationSCP2": 1565 }, "bd_linear_ncde": { - "EigenWorms": 3494, - "EthanolConcentration": 1192, - "Heartbeat": 2732, - "MotorImagery": 8612, - "SelfRegulationSCP1": 666, - "SelfRegulationSCP2": 932 + "EigenWorms": 2685, + "EthanolConcentration": 1661, + "Heartbeat": 2941, + "MotorImagery": 4735, + "SelfRegulationSCP1": 893, + "SelfRegulationSCP2": 1149 }, "diagonal_linear_ncde": { - "EigenWorms": 3486, - "EthanolConcentration": 670, - "Heartbeat": 920, - "MotorImagery": 6552, - "SelfRegulationSCP1": 662, - "SelfRegulationSCP2": 664 + "EigenWorms": 2685, + "EthanolConcentration": 893, + "Heartbeat": 1149, + "MotorImagery": 4733, + "SelfRegulationSCP1": 893, + "SelfRegulationSCP2": 895 }, "dense_linear_ncde": { - "EigenWorms": 18580, - "EthanolConcentration": 11170, - "Heartbeat": 2712, - "MotorImagery": 8622, - "SelfRegulationSCP1": 666, - "SelfRegulationSCP2": 11172 + "EigenWorms": 43649, + "EthanolConcentration": 11389, + "Heartbeat": 2941, + "MotorImagery": 4735, + "SelfRegulationSCP1": 895, + "SelfRegulationSCP2": 12929 + }, + "diagonal_dense_linear_ncde": { + "EigenWorms": 2687, + "EthanolConcentration": 1661, + "Heartbeat": 2945, + "MotorImagery": 4735, + "SelfRegulationSCP1": 893, + "SelfRegulationSCP2": 893 + }, + "bd_linear_ncde_recurrent": { + "EigenWorms": 2687, + "EthanolConcentration": 1149, + "Heartbeat": 2941, + "MotorImagery": 4735, + "SelfRegulationSCP1": 895, + "SelfRegulationSCP2": 893 + }, + "dense_linear_ncde_recurrent": { + "EigenWorms": 19071, + "EthanolConcentration": 4989, + "Heartbeat": 2941, + "MotorImagery": 4741, + "SelfRegulationSCP1": 893, + "SelfRegulationSCP2": 4991 + }, + "diagonal_dense_linear_ncde_recurrent": { + "EigenWorms": 2687, + "EthanolConcentration": 1149, + "Heartbeat": 2941, + "MotorImagery": 4737, + "SelfRegulationSCP1": 893, + "SelfRegulationSCP2": 893 + }, + "diagonal_linear_ncde_recurrent": { + "EigenWorms": 2687, + "EthanolConcentration": 893, + "Heartbeat": 1149, + "MotorImagery": 4733, + "SelfRegulationSCP1": 895, + "SelfRegulationSCP2": 893 } }, "time": { + "diagonal_linear_ncde_recurrent": { + "EigenWorms": 36.41, + "EthanolConcentration": 39.52, + "Heartbeat": 11.42, + "MotorImagery": 10.06, + "SelfRegulationSCP1": 6.36, + "SelfRegulationSCP2": 13.44 + }, + "diagonal_dense_linear_ncde_recurrent": { + "EigenWorms": 58.29, + "EthanolConcentration": 69.76, + "Heartbeat": 140.95, + "MotorImagery": 174.07, + "SelfRegulationSCP1": 10.38, + "SelfRegulationSCP2": 17.92 + }, + "dense_linear_ncde_recurrent": { + "EigenWorms": 77.74, + "EthanolConcentration": 56.29, + "Heartbeat": 159.96, + "MotorImagery": 166.15, + "SelfRegulationSCP1": 9.86, + "SelfRegulationSCP2": 21.10 + }, + "bd_linear_ncde_recurrent": { + "EigenWorms": 40.62, + "EthanolConcentration": 45.61, + "Heartbeat": 177.25, + "MotorImagery": 174.98, + "SelfRegulationSCP1": 7.29, + "SelfRegulationSCP2": 13.72 + }, + "diagonal_dense_linear_ncde": { + "EigenWorms": 19.09, + "EthanolConcentration": 21.12, + "Heartbeat": 161.07, + "MotorImagery": 171.19, + "SelfRegulationSCP1": 13.19, + "SelfRegulationSCP2": 14.74 + }, "dense_linear_ncde": { - "EigenWorms": 145.44, - "EthanolConcentration": 71.80, - "Heartbeat": 196.6, - "MotorImagery": 202.78, - "SelfRegulationSCP1": 8.27, - "SelfRegulationSCP2": 60.51 + "EigenWorms": 92.57, + "EthanolConcentration": 40.93, + "Heartbeat": 142.74, + "MotorImagery": 157.59, + "SelfRegulationSCP1": 10.34, + "SelfRegulationSCP2": 19.26 }, "bd_linear_ncde": { - "EigenWorms": 15.46, - "EthanolConcentration": 12.54, - "Heartbeat": 138.09, - "MotorImagery": 148.16, - "SelfRegulationSCP1": 6.77, - "SelfRegulationSCP2": 10.71 + "EigenWorms": 16.26, + "EthanolConcentration": 14.24, + "Heartbeat": 169.78, + "MotorImagery": 188.22, + "SelfRegulationSCP1": 8.12, + "SelfRegulationSCP2": 11.82 }, "diagonal_linear_ncde": { - "EigenWorms": 7.56, - "EthanolConcentration": 7.97, - "Heartbeat": 6.77, - "MotorImagery": 6.16, - "SelfRegulationSCP1": 6.39, - "SelfRegulationSCP2": 6.91 + "EigenWorms": 14.23, + "EthanolConcentration": 12.70, + "Heartbeat": 12.78, + "MotorImagery": 9.11, + "SelfRegulationSCP1": 7.84, + "SelfRegulationSCP2": 9.47 }, "ncde": { - "EigenWorms": 24595.42, - "EthanolConcentration": 2216.64, - "Heartbeat": 1177.36, - "MotorImagery": 3778.08, - "SelfRegulationSCP1": 972.58, - "SelfRegulationSCP2": 1251.17 + "EigenWorms": 30827.07, + "EthanolConcentration": 2530.46, + "Heartbeat": 800.15, + "MotorImagery": 4546.41, + "SelfRegulationSCP1": 1203.33, + "SelfRegulationSCP2": 1630.95 }, "nrde": { - "EigenWorms": 5386.09, - "EthanolConcentration": 2255.55, - "Heartbeat": 9539.08, - "MotorImagery": 7616.09, - "SelfRegulationSCP1": 1013.99, - "SelfRegulationSCP2": 1404.11 + "EigenWorms": 6830.97, + "EthanolConcentration": 2400.71, + "Heartbeat": 3048.67, + "MotorImagery": 5475.63, + "SelfRegulationSCP1": 1188.80, + "SelfRegulationSCP2": 1641.75 }, "log_ncde": { - "EigenWorms": 1956.45, - "EthanolConcentration": 2056.06, - "Heartbeat": 826.38, - "MotorImagery": 729.84, - "SelfRegulationSCP1": 634.89, - "SelfRegulationSCP2": 583.39 + "EigenWorms": 2351.97, + "EthanolConcentration": 2308.61, + "Heartbeat": 927.29, + "MotorImagery": 864.93, + "SelfRegulationSCP1": 714.47, + "SelfRegulationSCP2": 762.85 }, "lru": { - "EigenWorms": 93.53, - "EthanolConcentration": 16.28, - "Heartbeat": 7.66, - "MotorImagery": 50.98, - "SelfRegulationSCP1": 8.67, - "SelfRegulationSCP2": 8.71 + "EigenWorms": 48.10, + "EthanolConcentration": 28.93, + "Heartbeat": 13.27, + "MotorImagery": 42.90, + "SelfRegulationSCP1": 13.80, + "SelfRegulationSCP2": 14.47 }, "S5": { - "EigenWorms": 30.64, - "EthanolConcentration": 9.31, - "Heartbeat": 11.33, - "MotorImagery": 15.95, - "SelfRegulationSCP1": 16.74, - "SelfRegulationSCP2": 8.55 + "EigenWorms": 24.11, + "EthanolConcentration": 15.49, + "Heartbeat": 20.87, + "MotorImagery": 29.85, + "SelfRegulationSCP1": 27.04, + "SelfRegulationSCP2": 14.14 }, "mamba": { - "EigenWorms": 122.16, - "EthanolConcentration": 255.18, - "Heartbeat": 33.97, - "MotorImagery": 34.92, - "SelfRegulationSCP1": 6.66, - "SelfRegulationSCP2": 32.04 + "EigenWorms": 82.92, + "EthanolConcentration": 171.77, + "Heartbeat": 36.63, + "MotorImagery": 32.47, + "SelfRegulationSCP1": 5.24, + "SelfRegulationSCP2": 30.79 }, "S6": { - "EigenWorms": 67.72, - "EthanolConcentration": 4.15, - "Heartbeat": 4.04, - "MotorImagery": 33.72, - "SelfRegulationSCP1": 2.62, - "SelfRegulationSCP2": 6.84 + "EigenWorms": 53.73, + "EthanolConcentration": 6.33, + "Heartbeat": 6.51, + "MotorImagery": 42.18, + "SelfRegulationSCP1": 3.51, + "SelfRegulationSCP2": 8.25 } }, "num_steps": { diff --git a/results/time_vs_acc.py b/results/time_vs_acc.py new file mode 100644 index 0000000..a9ac4c9 --- /dev/null +++ b/results/time_vs_acc.py @@ -0,0 +1,143 @@ +import matplotlib +import matplotlib.pyplot as plt +from matplotlib.lines import Line2D + + +matplotlib.rcParams.update( + { + "font.size": 14, + } +) # Update default font size + +# ─────────────────────────── 1. DATA ────────────────────────────── +# Average test accuracy (%) +accuracy = { + "LRU": 61.7, + "S5": 61.8, + "S6": 62.0, + "MAMBA": 58.6, + "NCDE": 60.2, + "NRDE": 60.6, + "Log‑NCDE": 64.3, + "D‑SLiCE": 61.7, + "BD-SLiCE": 64.0, + "DE‑LNCDE": 61.6, +} + +# Time per 1 000 training steps (s) +time_1k = { + "LRU": 26.91, + "S5": 21.92, + "S6": 20.09, + "MAMBA": 59.97, + "NCDE": 6923.06, + "NRDE": 3431.09, + "Log‑NCDE": 1321.69, + "D‑SLiCE": 11.0, + "BD-SLiCE": 68.1, + "DE‑LNCDE": 77.2, +} + +# GPU memory (MB) +gpu_mem = { + "LRU": 4308.0, + "S5": 3327.33, + "S6": 2938.33, + "MAMBA": 4434.67, + "NCDE": 1961.67, + "NRDE": 2858.33, + "Log‑NCDE": 2177.33, + "D‑SLiCE": 1875.33, + "BD-SLiCE": 2344.00, + "DE‑LNCDE": 12756, +} + +text_pos = { + "LRU": (-12.5, -30), + "S5": (-13, -26), + "S6": (-10, 15), + "MAMBA": (-25, 18), + "NCDE": (-20, -23), + "NRDE": (-20, 15), + "Log‑NCDE": (-35, -25), + "D‑SLiCE": (-25, -25), + "BD-SLiCE": (-35, 15), + "DE‑LNCDE": (-35, 32), +} + +# ─────────────────────── 2. GROUP / COLOUR MAPPING ───────────────── +groups = { + "Non‑linear CDE": ["NCDE", "NRDE", "Log‑NCDE"], + "Linear CDE": [ + "D‑SLiCE", + "BD-SLiCE", + "DE‑LNCDE", + ], + "SSM": ["S5", "S6", "MAMBA"], + "RNN": ["LRU"], +} + +colours = { + "Non‑linear CDE": "#0072B2", # Blue + "Linear CDE": "#E69F00", # Orange + "SSM": "#009E73", # Green + "RNN": "#D55E00", # Vermilion (orange-red, not pure red) +} + +# ─────────────────────────── 3. PLOT ─────────────────────────────── +plt.figure(figsize=(10, 7)) + +handles = [] +for family, models in groups.items(): + x = [time_1k[m] for m in models] + y = [accuracy[m] for m in models] + sizes = [gpu_mem[m] / 4 for m in models] # scale so bubbles look good + h = plt.scatter( + x, + y, + s=sizes, + c=colours[family], + label=family, + alpha=0.75, + edgecolors="w", + linewidths=0.5, + ) + handles.append(h) + # annotate each point + for m in models: + pos = text_pos[m] + plt.annotate( + m, + (time_1k[m], accuracy[m]), + textcoords="offset points", + xytext=pos, + ha="left", + fontsize=14, + ) + +plt.xscale("log") +plt.xlabel("Time per 1000 training steps (s)") +plt.ylabel("Average test accuracy (%)") +plt.title("Accuracy, Speed, and Memory Footprint on the UEA-MTSCA") +# plt.grid(alpha=0.3, which='both', linestyle='--') +plt.ylim(58, 65) +legend_elements = [ + Line2D( + [0], + [0], + marker="o", + color="w", + label=family, + markerfacecolor=colours[family], + markersize=14, + alpha=0.75, + markeredgecolor="w", + markeredgewidth=0.5, + ) + for family in groups +] + +plt.legend(handles=legend_elements, title="Model family", loc=[0.5, 0.2]) +plt.tight_layout() +plt.savefig("results/images/time_vs_acc.pdf", dpi=300) +plt.show() diff --git a/run_experiment.py b/run_experiment.py index 0a6c049..13c63ac 100644 --- a/run_experiment.py +++ b/run_experiment.py @@ -23,7 +23,12 @@ import json -def run_experiments(model_names, dataset_names, experiment_folder, pytorch_experiments): +def run_experiments( + model_names, + dataset_names, + experiment_folder, + pytorch_experiments, +): for model_name in model_names: for dataset_name in dataset_names: @@ -54,6 +59,10 @@ def run_experiments(model_names, dataset_names, experiment_folder, pytorch_exper "bd_linear_ncde", "diagonal_linear_ncde", "dense_linear_ncde", + "wh_linear_ncde", + "sparse_linear_ncde", + "dplr_linear_ncde", + "diagonal_dense_linear_ncde", ]: dt0 = None else: @@ -78,18 +87,24 @@ def run_experiments(model_names, dataset_names, experiment_folder, pytorch_exper lambd = None ssm_dim = None num_blocks = None + parallel_steps = None + walsh_hadamard = None + diagonal_dense = None + sparsity = None + rank = None else: - if ( - model_name == "bd_linear_ncde" - or model_name == "diagonal_linear_ncde" - or model_name == "dense_linear_ncde" - ): + if model_name.endswith("_linear_ncde"): block_size = int(data["block_size"]) ssm_dim = None stepsize = int(float(data["stepsize"])) logsig_depth = int(data["depth"]) lambd = float(data["lambd"]) num_blocks = None + parallel_steps = int(data.get("parallel_steps", 1)) + walsh_hadamard = data.get("walsh_hadamard", False) + diagonal_dense = data.get("diagonal_dense", False) + sparsity = data.get("sparsity", 1.0) + rank = int(data.get("rank", 0)) else: block_size = None ssm_dim = int(data["ssm_dim"]) @@ -97,6 +112,11 @@ def run_experiments(model_names, dataset_names, experiment_folder, pytorch_exper logsig_depth = 1 lambd = None num_blocks = int(data["num_blocks"]) + parallel_steps = None + walsh_hadamard = None + diagonal_dense = None + sparsity = None + rank = None vf_depth = None vf_width = None if model_name == "S5": @@ -177,6 +197,11 @@ def run_experiments(model_names, dataset_names, experiment_folder, pytorch_exper "stepsize_controller": diffrax.ConstantStepSize(), "scale": scale, "lambd": lambd, + "parallel_steps": parallel_steps, + "walsh_hadamard": walsh_hadamard, + "diagonal_dense": diagonal_dense, + "sparsity": sparsity, + "rank": rank, } run_args = { "data_dir": data_dir, @@ -217,14 +242,18 @@ def run_experiments(model_names, dataset_names, experiment_folder, pytorch_exper model_names = ["mamba", "S6"] else: model_names = [ - "ncde", - "log_ncde", - "nrde", "S5", "lru", "bd_linear_ncde", - "dense_linear_ncde", + "ncde", + "log_ncde", + "nrde", "diagonal_linear_ncde", + "diagonal_dense_linear_ncde", + "dense_linear_ncde", + "wh_linear_ncde", + "sparse_linear_ncde", + "dplr_linear_ncde", ] dataset_names = [ "EigenWorms", @@ -236,4 +265,9 @@ def run_experiments(model_names, dataset_names, experiment_folder, pytorch_exper ] experiment_folder = "experiment_configs/repeats" - run_experiments(model_names, dataset_names, experiment_folder, pytorch_experiments) + run_experiments( + model_names, + dataset_names, + experiment_folder, + pytorch_experiments, + ) diff --git a/simple_example.ipynb b/simple_example.ipynb index 4c0f1d2..86108a1 100644 --- a/simple_example.ipynb +++ b/simple_example.ipynb @@ -2,7 +2,6 @@ "cells": [ { "cell_type": "markdown", - "metadata": {}, "source": [ "# A Simple Example\n", "\n", @@ -34,11 +33,14 @@ "## Considerations\n", "\n", "The following code is designed for simplicity and is not the most efficient implementation of NCDEs or Log-NCDEs. Specifically, calculating the coefficients for NCDEs and the log-signatures for Log-NCDEs should ideally be performed once for the entire dataset as a preprocessing step, rather than during each forward pass." - ] + ], + "metadata": { + "collapsed": false + } }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": { "collapsed": false, "jupyter": { @@ -47,11 +49,17 @@ "pycharm": { "is_executing": true, "name": "#%%\n" + }, + "ExecuteTime": { + "end_time": "2025-05-22T10:12:41.366180679Z", + "start_time": "2025-05-22T10:12:40.502108664Z" } }, "outputs": [], "source": [ "# Import necessary libraries\n", + "from typing import List, Tuple # Type hinting for lists and tuples\n", + "\n", "import diffrax # Differential equation solvers\n", "import equinox as eqx # Neural network library\n", "import jax # Main JAX library\n", @@ -59,6 +67,11 @@ "import jax.random as jr # JAX random number generation\n", "import matplotlib.pyplot as plt # Matplotlib for plotting\n", "import optax # Optimiser library for JAX\n", + "import roughpy as rp # Library for Hall basis\n", +<<<<<<< Updated upstream +======= + "from typing import List, Tuple # Type hinting for lists and tuples\n", +>>>>>>> Stashed changes "\n", "# Import specific functions from signax for handling log-signature calculation\n", "from signax.signature import signature # For computing signatures of paths\n", @@ -71,9 +84,37 @@ }, { "cell_type": "code", - "execution_count": 2, - "metadata": {}, +<<<<<<< Updated upstream + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2025-05-23T12:10:50.230612443Z", + "start_time": "2025-05-23T12:10:50.168265905Z" + } + }, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'eqx' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[1], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# Define the NeuralCDE class\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28;01mclass\u001b[39;00m \u001b[38;5;21;01mNeuralCDE\u001b[39;00m(\u001b[43meqx\u001b[49m\u001b[38;5;241m.\u001b[39mModule):\n\u001b[1;32m 3\u001b[0m vf: eqx\u001b[38;5;241m.\u001b[39mnn\u001b[38;5;241m.\u001b[39mMLP \u001b[38;5;66;03m# Vector field parameterised as an MLP\u001b[39;00m\n\u001b[1;32m 4\u001b[0m data_dim: \u001b[38;5;28mint\u001b[39m \u001b[38;5;66;03m# Dimension of the input data\u001b[39;00m\n", + "\u001b[0;31mNameError\u001b[0m: name 'eqx' is not defined" + ] + } + ], +======= + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2025-05-22T10:12:42.797921226Z", + "start_time": "2025-05-22T10:12:42.784677034Z" + } + }, "outputs": [], +>>>>>>> Stashed changes "source": [ "# Define the NeuralCDE class\n", "\n", @@ -157,10 +198,14 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": { "pycharm": { "is_executing": true + }, + "ExecuteTime": { + "end_time": "2025-05-22T10:12:44.105565820Z", + "start_time": "2025-05-22T10:12:44.099424499Z" } }, "outputs": [], @@ -285,25 +330,256 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, + "execution_count": 38, + "outputs": [], + "source": [ + "def to_tuple(el):\n", + " \"\"\"Convert a basis element which may be an int or a nested [x,y] list into a nested tuple.\"\"\"\n", + " if isinstance(el, int):\n", + " return (el,)\n", + " else:\n", + " return to_tuple(el[0]), to_tuple(el[1])\n", + "\n", + "\n", + "def depth(b):\n", + " \"\"\"Compute the 'depth' of a bracket structure.\"\"\"\n", + " if isinstance(b, int):\n", + " return 1\n", + " elif isinstance(b, list):\n", + " return max(depth(b[0]), depth(b[1])) + 1\n", + " else:\n", + " raise TypeError(\"Invalid basis element type.\")\n", + "\n", + "\n", + "class LogBlockDiagonalNeuralCDE:\n", + " \"\"\"\n", + " Block‑diagonal Linear Controlled Differential Equation layer.\n", + " \"\"\"\n", + "\n", + " init_layer: eqx.nn.Linear\n", + " out_layer: eqx.nn.Linear\n", + " vf_A: jnp.ndarray\n", + " hidden_dim: int\n", + " block_size: int\n", + " num_blocks: int\n", + " parallel_steps: int\n", + " logsig_depth: int\n", + " basis_list: List[Tuple[int, ...]]\n", + " stepsize: int\n", + " lambd: float\n", + "\n", + " classification: bool = True\n", + " lip2: bool = True\n", + " nondeterministic: bool = False\n", + " stateful: bool = False\n", + "\n", + " def __init__(\n", + " self,\n", + " *,\n", + " data_dim: int,\n", + " hidden_dim: int,\n", + " label_dim: int,\n", + " block_size: int,\n", + " logsig_depth: int,\n", + " stepsize: int,\n", + " lambd: float = 1.0,\n", + " w_init_std: float = 0.25,\n", + " parallel_steps: int = 128,\n", + " key,\n", + " ):\n", + " if hidden_dim % block_size != 0:\n", + " raise ValueError(\"hidden_dim must be divisible by block_size.\")\n", + " self.hidden_dim = hidden_dim\n", + " self.block_size = block_size\n", + " self.num_blocks = hidden_dim // block_size\n", + " self.parallel_steps = parallel_steps\n", + " self.logsig_depth = logsig_depth\n", + " self.stepsize = stepsize\n", + " ctx = rp.get_context(width=data_dim, depth=self.logsig_depth, coeffs=rp.DPReal)\n", + " basis = ctx.lie_basis\n", + " basis_list = []\n", + " for i in range(basis.size(self.logsig_depth)):\n", + " basis_list.append(eval(str(basis.index_to_key(i))))\n", + " self.basis_list = basis_list\n", + " self.lambd = lambd\n", + "\n", + " k_init, k_A, k_B = jr.split(key, 3)\n", + " self.init_layer = eqx.nn.Linear(data_dim, hidden_dim, key=k_init)\n", + " self.out_layer = eqx.nn.Linear(hidden_dim, label_dim, key=k_B)\n", + "\n", + " self.vf_A = (\n", + " jr.normal(k_A, (data_dim + 1, self.num_blocks * block_size * block_size))\n", + " * w_init_std\n", + " / jnp.sqrt(block_size)\n", + " )\n", + "\n", + " self.hall_set = HallSet(data_dim, logsig_depth)\n", + "\n", + " # Method to calculate log-signatures\n", +<<<<<<< Updated upstream + "\n", +======= +>>>>>>> Stashed changes + " def calc_logsigs(self, X):\n", + " # Reshape data\n", + " X = X.reshape(-1, self.stepsize, X.shape[-1])\n", + "\n", + " # Prepend zero to the first interval and the last element of the previous interval to every other interval\n", + " prepend = jnp.concatenate((jnp.zeros((1, X.shape[-1])), X[:-1, -1, :]))[\n", + " :, None, :\n", + " ]\n", + " X = jnp.concatenate((prepend, X), axis=1)\n", + "\n", + " # Define log-signature function\n", + " def logsig(x):\n", + " logsig = flatten(log(signature(x, self.logsig_depth)))\n", + " if self.logsig_depth == 1:\n", + " return jnp.concatenate((jnp.array([0]), logsig))\n", + " else:\n", + " tensor_to_lie_map = self.hall_set.t2l_matrix(self.logsig_depth)\n", + " return tensor_to_lie_map[:, 1:] @ logsig\n", + "\n", + " # Calculate log-signatures over each interval\n", + " logsigs = jax.vmap(logsig)(X)\n", + "\n", + " return logsigs\n", + "\n", + " def log_ode(self, vf):\n", + "\n", + " basis_index = {}\n", + " for i, b in enumerate(self.basis_list):\n", + " basis_index[to_tuple(b)] = i\n", + "\n", + " depth_to_elements = {}\n", + " for i, b in enumerate(self.basis_list):\n", + " d = depth(b)\n", + " depth_to_elements.setdefault(d, []).append((i, b))\n", + "\n", + " A_arrays = [None] * len(self.basis_list)\n", + "\n", + " for i_b, b in depth_to_elements[1]:\n", + " A_arrays[i_b] = vf[b - 1, :, :]\n", + "\n", + " max_depth = max(depth_to_elements.keys())\n", + " for d in range(2, max_depth + 1):\n", + " curr_elements = depth_to_elements[d]\n", + "\n", + " left_indices = []\n", + " right_indices = []\n", +<<<<<<< Updated upstream + " for i_b, b in curr_elements:\n", +======= + " for (i_b, b) in curr_elements:\n", +>>>>>>> Stashed changes + " u_tuple = to_tuple(b[0])\n", + " v_tuple = to_tuple(b[1])\n", + " i_u = basis_index[u_tuple]\n", + " i_v = basis_index[v_tuple]\n", + " left_indices.append(i_u)\n", + " right_indices.append(i_v)\n", + "\n", + " A_left = jnp.stack([A_arrays[i_u] for i_u in left_indices], axis=0)\n", + " A_right = jnp.stack([A_arrays[i_v] for i_v in right_indices], axis=0)\n", + "\n", + " A_uv = jnp.einsum(\"ijk,ikl->ijl\", A_right, A_left) - jnp.einsum(\n", + " \"ijk,ikl->ijl\", A_left, A_right\n", + " )\n", + "\n", + " for idx, (i_b, b) in enumerate(curr_elements):\n", + " A_arrays[i_b] = A_uv[idx]\n", + "\n", + " return jnp.stack(A_arrays, axis=2)\n", + "\n", + " def __call__(self, X):\n", + " x0 = X[0, :]\n", + " logsigs = self.calc_logsigs(X)\n", + "\n", + " y0 = self.init_layer(x0)\n", + "\n", + " vfs = self.vf_A.reshape(-1, self.num_blocks, self.block_size, self.block_size)\n", + " lie_brackets = jax.vmap(self.log_ode, in_axes=(1))(vfs)\n", + " log_flows = jnp.einsum(\"ijkl,ml->mijk\", lie_brackets, logsigs[:, 1:])\n", + " flows = log_flows + jnp.eye(self.block_size)[None, None, :, :]\n", + "\n", + " def step(y, flow):\n", + " y_block = y.reshape(self.num_blocks, self.block_size, 1)\n", + " y_next = flow @ y_block\n", + " y_next = y_next.reshape(\n", + " self.hidden_dim,\n", + " )\n", + " return y_next, y_next\n", + "\n", + " def parallel_step(y, flows):\n", + " compose = lambda a, b: jnp.matmul(b, a)\n", + " flow_total = jax.lax.associative_scan(compose, flows)\n", + " y_block = y.reshape(self.num_blocks, self.block_size, 1)\n", + " y_new = jnp.matmul(flow_total, y_block).reshape(-1, self.hidden_dim)\n", + " return y_new[-1], y_new\n", + "\n", + " if self.parallel_steps == 1:\n", + " scan_fn = step\n", + " remainder = 0\n", + " scan_inp = flows\n", + " else:\n", + " scan_fn = parallel_step\n", + " t = len(flows)\n", + " remainder = (t - 1) % self.parallel_steps\n", + " core = flows[1:] if remainder == 0 else flows[1:-remainder]\n", + " scan_inp = jnp.reshape(\n", + " core,\n", + " (\n", + " -1,\n", + " self.parallel_steps,\n", + " self.num_blocks,\n", + " self.block_size,\n", + " self.block_size,\n", + " ),\n", + " )\n", + "\n", + " _, ys = jax.lax.scan(scan_fn, y0, scan_inp) # (T‑1, H)\n", + " if len(ys.shape) == 3:\n", + " ys = jnp.reshape(ys, (-1, self.hidden_dim))\n", + " ys = jnp.vstack([y0, ys])\n", + " if remainder != 0:\n", + " inp_rem = flows[-remainder:]\n", + " _, y_rem = jax.lax.scan(step, ys[-1], inp_rem)\n", + " ys = jnp.vstack([ys, y_rem])\n", +<<<<<<< Updated upstream + " return jax.nn.softmax(self.out_layer(ys[-1]))" +======= + " return jax.nn.softmax(self.out_layer(ys[-1]))\n" +>>>>>>> Stashed changes + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2025-05-22T11:10:07.722806256Z", + "start_time": "2025-05-22T11:10:07.681034445Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "ExecuteTime": { + "end_time": "2025-05-22T11:06:21.366908523Z", + "start_time": "2025-05-22T11:05:41.386717290Z" + } + }, "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -423,8 +699,13 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, + "execution_count": 39, + "metadata": { + "ExecuteTime": { + "end_time": "2025-05-22T11:10:13.995972941Z", + "start_time": "2025-05-22T11:10:13.929345862Z" + } + }, "outputs": [], "source": [ "# Define the Dataloader class\n", @@ -467,8 +748,13 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, + "execution_count": 45, + "metadata": { + "ExecuteTime": { + "end_time": "2025-05-22T11:12:57.344830556Z", + "start_time": "2025-05-22T11:12:57.302847950Z" + } + }, "outputs": [], "source": [ "# Define the classification loss function with gradient calculation\n", @@ -497,8 +783,13 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, + "execution_count": 41, + "metadata": { + "ExecuteTime": { + "end_time": "2025-05-22T11:10:14.377530819Z", + "start_time": "2025-05-22T11:10:14.376237940Z" + } + }, "outputs": [], "source": [ "# Define the training function for the model\n", @@ -561,79 +852,40 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, + "execution_count": 46, + "metadata": { + "ExecuteTime": { + "end_time": "2025-05-22T11:59:32.108893231Z", + "start_time": "2025-05-22T11:14:44.210804912Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "----------- NCDE -----------\n", - "Step: 1, Train Acc: 0.48625001311302185, Test Acc: 0.4750000238418579\n", - "Step: 100, Train Acc: 0.5422500371932983, Test Acc: 0.5450000166893005\n", - "Step: 200, Train Acc: 0.6252500414848328, Test Acc: 0.6010000109672546\n", - "Step: 300, Train Acc: 0.6140000224113464, Test Acc: 0.6030000448226929\n", - "Step: 400, Train Acc: 0.6672500371932983, Test Acc: 0.6840000152587891\n", - "Step: 500, Train Acc: 0.7070000171661377, Test Acc: 0.7090000510215759\n", - "Step: 600, Train Acc: 0.7127500176429749, Test Acc: 0.7220000624656677\n", - "Step: 700, Train Acc: 0.7142500281333923, Test Acc: 0.7200000286102295\n", - "Step: 800, Train Acc: 0.7090000510215759, Test Acc: 0.7120000123977661\n", - "Step: 900, Train Acc: 0.7192500233650208, Test Acc: 0.7260000109672546\n", - "Step: 1000, Train Acc: 0.7270000576972961, Test Acc: 0.7240000367164612\n", - "Step: 1100, Train Acc: 0.7262500524520874, Test Acc: 0.7230000495910645\n", - "Step: 1200, Train Acc: 0.737000048160553, Test Acc: 0.7480000257492065\n", - "Step: 1300, Train Acc: 0.7402500510215759, Test Acc: 0.7580000162124634\n", - "Step: 1400, Train Acc: 0.7440000176429749, Test Acc: 0.7550000548362732\n", - "Step: 1500, Train Acc: 0.749750018119812, Test Acc: 0.7550000548362732\n", - "Step: 1600, Train Acc: 0.7532500624656677, Test Acc: 0.7610000371932983\n", - "Step: 1700, Train Acc: 0.7575000524520874, Test Acc: 0.76500004529953\n", - "Step: 1800, Train Acc: 0.7635000348091125, Test Acc: 0.7680000066757202\n", - "Step: 1900, Train Acc: 0.768750011920929, Test Acc: 0.7770000100135803\n", - "Step: 2000, Train Acc: 0.7640000581741333, Test Acc: 0.7660000324249268\n", - "----------- Log-NCDE Depth 1 -----------\n", - "Step: 1, Train Acc: 0.5010000467300415, Test Acc: 0.47700002789497375\n", - "Step: 100, Train Acc: 0.5335000157356262, Test Acc: 0.5060000419616699\n", - "Step: 200, Train Acc: 0.6855000257492065, Test Acc: 0.6810000538825989\n", - "Step: 300, Train Acc: 0.7575000524520874, Test Acc: 0.7630000114440918\n", - "Step: 400, Train Acc: 0.783750057220459, Test Acc: 0.7990000247955322\n", - "Step: 500, Train Acc: 0.8140000104904175, Test Acc: 0.8220000267028809\n", - "Step: 600, Train Acc: 0.8280000686645508, Test Acc: 0.8350000381469727\n", - "Step: 700, Train Acc: 0.8367500305175781, Test Acc: 0.8460000157356262\n", - "Step: 800, Train Acc: 0.8380000591278076, Test Acc: 0.8500000238418579\n", - "Step: 900, Train Acc: 0.8390000462532043, Test Acc: 0.8540000319480896\n", - "Step: 1000, Train Acc: 0.8440000414848328, Test Acc: 0.8600000143051147\n", - "Step: 1100, Train Acc: 0.8450000286102295, Test Acc: 0.8570000529289246\n", - "Step: 1200, Train Acc: 0.846250057220459, Test Acc: 0.8600000143051147\n", - "Step: 1300, Train Acc: 0.8470000624656677, Test Acc: 0.859000027179718\n", - "Step: 1400, Train Acc: 0.8457500338554382, Test Acc: 0.8580000400543213\n", - "Step: 1500, Train Acc: 0.8472500443458557, Test Acc: 0.8630000352859497\n", - "Step: 1600, Train Acc: 0.846250057220459, Test Acc: 0.862000048160553\n", - "Step: 1700, Train Acc: 0.8470000624656677, Test Acc: 0.8640000224113464\n", - "Step: 1800, Train Acc: 0.8470000624656677, Test Acc: 0.8640000224113464\n", - "Step: 1900, Train Acc: 0.846250057220459, Test Acc: 0.862000048160553\n", - "Step: 2000, Train Acc: 0.8485000133514404, Test Acc: 0.8660000562667847\n", "----------- Log-NCDE Depth 2 -----------\n", - "Step: 1, Train Acc: 0.502750039100647, Test Acc: 0.47600001096725464\n", - "Step: 100, Train Acc: 0.6487500071525574, Test Acc: 0.6320000290870667\n", - "Step: 200, Train Acc: 0.7935000658035278, Test Acc: 0.7900000214576721\n", - "Step: 300, Train Acc: 0.8525000214576721, Test Acc: 0.8570000529289246\n", - "Step: 400, Train Acc: 0.8990000486373901, Test Acc: 0.8950000405311584\n", - "Step: 500, Train Acc: 0.9230000376701355, Test Acc: 0.9250000715255737\n", - "Step: 600, Train Acc: 0.9360000491142273, Test Acc: 0.9250000715255737\n", - "Step: 700, Train Acc: 0.940500020980835, Test Acc: 0.9360000491142273\n", - "Step: 800, Train Acc: 0.9447500705718994, Test Acc: 0.940000057220459\n", - "Step: 900, Train Acc: 0.9460000395774841, Test Acc: 0.9440000653266907\n", - "Step: 1000, Train Acc: 0.9477500319480896, Test Acc: 0.9410000443458557\n", - "Step: 1100, Train Acc: 0.9500000476837158, Test Acc: 0.9470000267028809\n", - "Step: 1200, Train Acc: 0.9510000348091125, Test Acc: 0.9490000605583191\n", - "Step: 1300, Train Acc: 0.95250004529953, Test Acc: 0.9500000476837158\n", - "Step: 1400, Train Acc: 0.9540000557899475, Test Acc: 0.9500000476837158\n", - "Step: 1500, Train Acc: 0.9550000429153442, Test Acc: 0.9490000605583191\n", - "Step: 1600, Train Acc: 0.9545000195503235, Test Acc: 0.9490000605583191\n", - "Step: 1700, Train Acc: 0.9567500352859497, Test Acc: 0.9490000605583191\n", - "Step: 1800, Train Acc: 0.9577500224113464, Test Acc: 0.9520000219345093\n", - "Step: 1900, Train Acc: 0.9575000405311584, Test Acc: 0.9490000605583191\n", - "Step: 2000, Train Acc: 0.9580000638961792, Test Acc: 0.9520000219345093\n" + "Step: 1, Train Acc: 0.4792500138282776, Test Acc: 0.49500003457069397\n", + "Step: 100, Train Acc: 0.6160000562667847, Test Acc: 0.6290000081062317\n", + "Step: 200, Train Acc: 0.8410000205039978, Test Acc: 0.8410000205039978\n", + "Step: 300, Train Acc: 0.862500011920929, Test Acc: 0.8660000562667847\n", + "Step: 400, Train Acc: 0.9015000462532043, Test Acc: 0.9050000309944153\n", + "Step: 500, Train Acc: 0.9307500720024109, Test Acc: 0.9320000410079956\n", + "Step: 600, Train Acc: 0.9417500495910645, Test Acc: 0.9450000524520874\n", + "Step: 700, Train Acc: 0.9495000243186951, Test Acc: 0.9500000476837158\n", + "Step: 800, Train Acc: 0.9537500739097595, Test Acc: 0.9490000605583191\n", + "Step: 900, Train Acc: 0.9567500352859497, Test Acc: 0.9490000605583191\n", + "Step: 1000, Train Acc: 0.9585000276565552, Test Acc: 0.9490000605583191\n", + "Step: 1100, Train Acc: 0.9580000638961792, Test Acc: 0.9490000605583191\n", + "Step: 1200, Train Acc: 0.9585000276565552, Test Acc: 0.9490000605583191\n", + "Step: 1300, Train Acc: 0.9582500457763672, Test Acc: 0.9490000605583191\n", + "Step: 1400, Train Acc: 0.9575000405311584, Test Acc: 0.9510000348091125\n", + "Step: 1500, Train Acc: 0.9600000381469727, Test Acc: 0.9490000605583191\n", + "Step: 1600, Train Acc: 0.9597500562667847, Test Acc: 0.9490000605583191\n", + "Step: 1700, Train Acc: 0.9605000615119934, Test Acc: 0.9510000348091125\n", + "Step: 1800, Train Acc: 0.9605000615119934, Test Acc: 0.9530000686645508\n", + "Step: 1900, Train Acc: 0.9595000743865967, Test Acc: 0.9470000267028809\n", + "Step: 2000, Train Acc: 0.9605000615119934, Test Acc: 0.9490000605583191\n" ] } ], @@ -680,13 +932,28 @@ " depth=2,\n", " key=modelkey,\n", ")\n", + "LogBDLNCDE_Depth3 = LogBlockDiagonalNeuralCDE(\n", + " data_dim=data_dim,\n", + " hidden_dim=hidden_dim,\n", + " label_dim=label_dim,\n", + " block_size=8,\n", + " logsig_depth=1,\n", + " stepsize=1,\n", + " key=modelkey,\n", + ")\n", "\n", "# Train models and collect test accuracies\n", "trainkey, key = jr.split(key)\n", "results = []\n", "for model, model_name in zip(\n", - " [NCDE, LogNCDE_Depth1, LogNCDE_Depth2],\n", - " [\"NCDE\", \"Log-NCDE Depth 1\", \"Log-NCDE Depth 2\"],\n", + " # [NCDE, LogNCDE_Depth1, LogNCDE_Depth2, LogBDLNCDE_Depth3],\n", + " # [\"NCDE\", \"Log-NCDE Depth 1\", \"Log-NCDE Depth 2\", \"Log-BD-LNCDE Depth 3\"],\n", + " [LogNCDE_Depth2],\n", +<<<<<<< Updated upstream + " [\"Log-NCDE Depth 2\"],\n", +======= + " [\"Log-NCDE Depth 2\"]\n", +>>>>>>> Stashed changes "):\n", " print(f\"----------- {model_name} -----------\")\n", " steps, test_accs = train_model(model, key=trainkey)\n", diff --git a/torch_experiments/jax_dataset.py b/torch_experiments/jax_dataset.py index 6c3c379..2c939d9 100644 --- a/torch_experiments/jax_dataset.py +++ b/torch_experiments/jax_dataset.py @@ -21,9 +21,18 @@ class Dataset(torch.utils.data.Dataset): def __init__( - self, data_dir, name, train, val, test, indexes, presplit, include_time + self, + data_dir, + name, + train, + val, + test, + indexes, + presplit, + include_time, ): super().__init__() + uea_subfolders = [ f.name for f in os.scandir(data_dir + "/processed/UEA") if f.is_dir() ] @@ -75,6 +84,7 @@ def __init__( np.arange(data.shape[1])[None, :], data.shape[0], axis=0 ) data = np.concatenate([ts[:, :, None], data], axis=2) + self.data = torch.from_numpy(data).to(torch.float32) self.labels = torch.from_numpy(labels).to(torch.float32) else: @@ -111,11 +121,11 @@ def __init__( np.arange(data.shape[1])[None, :], data.shape[0], axis=0 ) data = np.concatenate([ts[:, :, None], data], axis=2) - data = torch.from_numpy(data).to(torch.float32) - labels = torch.from_numpy(labels).to(torch.float32) assert len(indexes) == len(data) data = data[indexes] labels = labels[indexes] + data = torch.from_numpy(data).to(torch.float32) + labels = torch.from_numpy(labels).to(torch.float32) num_classes = len(torch.unique(labels)) if train: data = data[: int(0.7 * len(data))] diff --git a/train.py b/train.py index dd6bcd9..0905cf8 100644 --- a/train.py +++ b/train.py @@ -83,8 +83,13 @@ def classification_loss(diff_model, static_model, X, y, state, key): jnp.linalg.norm(layer.weight, axis=-1) + jnp.linalg.norm(layer.bias, axis=-1) ) - else: + elif model.vf_A is not None: norm += jnp.mean(jnp.linalg.norm(model.vf_A, axis=-1)) + elif model.vf_A_sparse is not None: + vf_A = model.vf_A_sparse.todense() + norm += jnp.mean(jnp.linalg.norm(vf_A, axis=-1)) + else: + norm = 0.0 norm *= model.lambd return ( jnp.mean(-jnp.sum(y * jnp.log(pred_y + 1e-8), axis=1)) + norm, @@ -108,8 +113,14 @@ def regression_loss(diff_model, static_model, X, y, state, key): jnp.linalg.norm(layer.weight, axis=-1) + jnp.linalg.norm(layer.bias, axis=-1) ) - else: + elif model.vf_A is not None: norm += jnp.mean(jnp.linalg.norm(model.vf_A, axis=-1)) + elif model.vf_A_sparse is not None: + vf_A = model.vf_A_sparse.todense() + norm += jnp.mean(jnp.linalg.norm(vf_A, axis=-1)) + else: + norm = 0.0 + norm *= model.lambd return ( jnp.mean(jnp.mean((pred_y - y) ** 2, axis=1)) + norm, state, @@ -196,28 +207,27 @@ def train_model( stepkey, key = jr.split(key, 2) X, y = data - if ( - model_name == "bd_linear_ncde" - or model_name == "diagonal_linear_ncde" - or model_name == "dense_linear_ncde" - ) and dataset_name == "Heartbeat": + if model_name == "dplr_linear_ncde": + if dataset_name == "Heartbeat" or dataset_name == "MotorImagery": + X = (X[0], X[1] / 100, X[2]) + elif model_name.endswith("linear_ncde") and dataset_name == "Heartbeat": X = (X[0], X[1] / 10, X[2]) model, state, opt_state, value = make_step( model, filter_spec, X, y, loss_fn, state, opt, opt_state, stepkey ) running_loss += value if (step + 1) % print_steps == 0: + end = time.time() predictions = [] labels = [] for data in dataloaders["train"].loop_epoch(batch_size): stepkey, key = jr.split(key, 2) inference_model = eqx.tree_inference(model, value=True) X, y = data - if ( - model_name == "bd_linear_ncde" - or model_name == "diagonal_linear_ncde" - or model_name == "dense_linear_ncde" - ) and dataset_name == "Heartbeat": + if model_name == "dplr_linear_ncde": + if dataset_name == "Heartbeat" or dataset_name == "MotorImagery": + X = (X[0], X[1] / 100, X[2]) + elif model_name.endswith("linear_ncde") and dataset_name == "Heartbeat": X = (X[0], X[1] / 10, X[2]) prediction, _ = calc_output( inference_model, @@ -244,11 +254,10 @@ def train_model( stepkey, key = jr.split(key, 2) inference_model = eqx.tree_inference(model, value=True) X, y = data - if ( - model_name == "bd_linear_ncde" - or model_name == "diagonal_linear_ncde" - or model_name == "dense_linear_ncde" - ) and dataset_name == "Heartbeat": + if model_name == "dplr_linear_ncde": + if dataset_name == "Heartbeat" or dataset_name == "MotorImagery": + X = (X[0], X[1] / 100, X[2]) + elif model_name.endswith("linear_ncde") and dataset_name == "Heartbeat": X = (X[0], X[1] / 10, X[2]) prediction, _ = calc_output( inference_model, @@ -269,7 +278,6 @@ def train_model( else: prediction = prediction[:, :, 0] val_metric = jnp.mean(jnp.mean((prediction - y) ** 2, axis=1), axis=0) - end = time.time() total_time = end - start print( f"Step: {step + 1}, Loss: {running_loss / print_steps}, " @@ -292,11 +300,16 @@ def train_model( stepkey, key = jr.split(key, 2) inference_model = eqx.tree_inference(model, value=True) X, y = data - if ( - model_name == "bd_linear_ncde" - or model_name == "diagonal_linear_ncde" - or model_name == "dense_linear_ncde" - ) and dataset_name == "Heartbeat": + if model_name == "dplr_linear_ncde": + if ( + dataset_name == "Heartbeat" + or dataset_name == "MotorImagery" + ): + X = (X[0], X[1] / 100, X[2]) + elif ( + model_name.endswith("linear_ncde") + and dataset_name == "Heartbeat" + ): X = (X[0], X[1] / 10, X[2]) prediction, _ = calc_output( inference_model, @@ -377,14 +390,15 @@ def create_dataset_model_and_train( output_dir += f"_stepsize_{stepsize:.2f}_depth_{logsig_depth}" for k, v in model_args.items(): name = str(v) - if "(" in name: - name = name.split("(", 1)[0] - if name == "dt0": - output_dir += f"_{k}_" + f"{v:.2f}" - else: - output_dir += f"_{k}_" + name - if name == "PIDController": - output_dir += f"_rtol_{v.rtol}_atol_{v.atol}" + if v is not None: + if "(" in name: + name = name.split("(", 1)[0] + if name == "dt0": + output_dir += f"_{k}_" + f"{v:.2f}" + else: + output_dir += f"_{k}_" + name + if name == "PIDController": + output_dir += f"_rtol_{v.rtol}_atol_{v.atol}" output_dir += f"_seed_{seed}" key = jr.PRNGKey(seed) @@ -392,11 +406,7 @@ def create_dataset_model_and_train( datasetkey, modelkey, trainkey, key = jr.split(key, 4) print(f"Creating dataset {dataset_name}") - if ( - model_name == "bd_linear_ncde" - or model_name == "diagonal_linear_ncde" - or model_name == "dense_linear_ncde" - ): + if model_name.endswith("linear_ncde"): scale = True else: scale = False @@ -432,9 +442,7 @@ def create_dataset_model_and_train( if ( model_name == "nrde" or model_name == "log_ncde" - or model_name == "bd_linear_ncde" - or model_name == "diagonal_linear_ncde" - or model_name == "dense_linear_ncde" + or model_name.endswith("linear_ncde") ): dataloaders = dataset.path_dataloaders if model_name == "log_ncde": @@ -445,6 +453,9 @@ def create_dataset_model_and_train( elif model_name == "nrde": where = lambda model: (model.intervals,) filter_spec = eqx.tree_at(where, filter_spec, replace=(False,)) + elif model_name == "wh_linear_ncde": + where = lambda model: (model.hadamard_matrix,) + filter_spec = eqx.tree_at(where, filter_spec, replace=(False,)) elif model_name == "ncde": dataloaders = dataset.coeff_dataloaders else: