{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"G2Net Gravitational Wave Detection\n",
"==================================\n",
"CNN-1D + GeM Pooling + SGDW Optimizer + Highpass Signal Filter\n",
"--------------------------------------\n",
"\n",
"- [1 Install packages, imports and settings](#install-imports-settings)\n",
"- [2 Definitions](#definitions)\n",
" - [2.1 Front-end: signal filter and dataset builder](#front-end)\n",
" - [2.2 CNN model and GeM layer](#cnn-model-gem-layer)\n",
" - [2.3 Training and inference functions](#training-inference-functions)\n",
"- [3 Configuration](#configuration)\n",
"- [4 Run training and inference](#run-training-inference)\n",
"- [5 Offline inference from multiple runs of folds](#offline-inference)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 1 Install packages, imports and settings "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "a8yb6r66B9hJ",
"outputId": "93af6564-0036-42b7-81d2-0f7384dd63ae"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\u001b[K |████████████████████████████████| 1.1 MB 4.1 MB/s \n",
"\u001b[K |████████████████████████████████| 1.1 MB 6.2 MB/s \n",
"\u001b[K |████████████████████████████████| 133 kB 91.6 MB/s \n",
"\u001b[K |████████████████████████████████| 94 kB 2.3 MB/s \n",
"\u001b[K |████████████████████████████████| 144 kB 59.1 MB/s \n",
"\u001b[K |████████████████████████████████| 271 kB 75.5 MB/s \n",
"\u001b[?25h"
]
}
],
"source": [
"%pip install -qU tensorflow_addons\n",
"%pip install -qU gcsfs"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "t7nVySYUINxS",
"outputId": "96b60f11-da46-47e2-cc0a-8c9c386aad83"
},
"outputs": [
{
"data": {
"text/plain": [
"[LogicalDevice(name='/device:CPU:0', device_type='CPU'),\n",
" LogicalDevice(name='/device:GPU:0', device_type='GPU')]"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import os\n",
"from pathlib import Path\n",
"import logging\n",
"import json, joblib\n",
"from datetime import datetime\n",
"from collections import namedtuple\n",
"from functools import partial\n",
"\n",
"# Numerical, stats and ML\n",
"import pandas as pd\n",
"import numpy as np\n",
"import dask.array as da\n",
"from scipy import signal\n",
"from sklearn.model_selection import StratifiedKFold, KFold\n",
"import tensorflow as tf\n",
"from tensorflow import keras\n",
"import tensorflow_addons as tfa\n",
"from keras.callbacks import ModelCheckpoint\n",
"\n",
"os.environ['TF_CPP_MIN_LOG_LEVEL'] = '1'\n",
"tf.get_logger().setLevel('WARNING')\n",
"tf.config.list_logical_devices()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 2 Definitions "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 2.1 Front-end: signal filter and dataset builder "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "Cn9JfGX4INxk"
},
"outputs": [],
"source": [
"class SignalFilter:\n",
" \"\"\"\n",
" Cell 33 of https://www.gw-openscience.org/LVT151012data/LOSC_Event_tutorial_LVT151012.html\n",
" https://scipy-cookbook.readthedocs.io/items/ButterworthBandpass.html\n",
" \"\"\"\n",
" def __init__(self, scaling: np.ndarray, filter_type: str='highpass',\n",
" filter_order: int=5, f_lo: float=20.43, f_hi: float=None,\n",
" sampling_rate: int=2048):\n",
" self.scaling = scaling\n",
" self.filter_type = filter_type\n",
" if filter_type.lower() == 'highpass':\n",
" Wn = f_lo\n",
" self.filter_window = signal.tukey(4096, 0.1)\n",
" self.filter_norm = np.sqrt(1 - f_lo / (sampling_rate / 2))\n",
" elif filter_type.lower() == 'bandpass':\n",
" Wn = [f_lo, f_hi]\n",
" self.filter_window = signal.tukey(4096, 0.1)\n",
" self.filter_norm = np.sqrt((f_hi - f_lo) / (sampling_rate / 2))\n",
" else:\n",
" raise ValueError('Unknown filter type.')\n",
" self.filter = signal.butter(N=filter_order, Wn=Wn, btype=filter_type, output='sos', fs=sampling_rate)\n",
"\n",
" def filt(self, X):\n",
" X = self.scaling * X * self.filter_window\n",
" if self.filter_type.lower() == 'bandpass':\n",
" X = signal.sosfilt(self.filter, X)\n",
" elif self.filter_type.lower() == 'highpass':\n",
" X = signal.sosfiltfilt(self.filter, X)\n",
" X *= self.filter_norm\n",
" return X\n",
"\n",
"class Data:\n",
" \"\"\"\n",
" Dataset builder.\n",
" \"\"\"\n",
" tfrec_format_train = {\n",
" \"wave\": tf.io.FixedLenFeature([], tf.string),\n",
" \"target\": tf.io.FixedLenFeature([], tf.int64),\n",
" \"wave_id\": tf.io.FixedLenFeature([], tf.string),\n",
" }\n",
"\n",
" tfrec_format_test = {\n",
" \"wave\": tf.io.FixedLenFeature([], tf.string),\n",
" \"wave_id\": tf.io.FixedLenFeature([], tf.string)\n",
" }\n",
"\n",
" AUTO = tf.data.AUTOTUNE\n",
"\n",
" def __init__(self, config):\n",
" self.config = config\n",
"\n",
" # Data file paths\n",
" self.train_files = [config.data_path + f'train{i}.tfrecords' for i in range(20)]\n",
" self.test_files = [config.data_path + f'test{i}.tfrecords' for i in range(10)]\n",
"\n",
" # Front-end signal filter\n",
" self.filter = SignalFilter(**config.filter)\n",
"\n",
" def _preprocess(self, X, y, train_or_test=True):\n",
" \"\"\"\n",
" Preprocess a batch of data: scaling, filtering, transpose. Casting to tf.float32 is done in wrapper.\n",
" \"\"\"\n",
" X = X.numpy()\n",
" X = self.filter.filt(X)\n",
" X = np.transpose(X, axes=(0, 2, 1))\n",
" if train_or_test:\n",
" return X, y\n",
" else:\n",
" return X\n",
"\n",
" def _preprocess_wrapper(self, train_or_test=True):\n",
" if train_or_test:\n",
" def wrapper(X, y):\n",
" return tf.py_function(\n",
" self._preprocess,\n",
" inp=[X, y], Tout=[tf.float32, tf.float32])\n",
" else:\n",
" def wrapper(X):\n",
" return tf.py_function(\n",
" partial(self._preprocess, y=None, train_or_test=False),\n",
" inp=[X], Tout=tf.float32)\n",
" return wrapper\n",
"\n",
" def _decode_train(self, tfrecord):\n",
" tensor_dict = tf.io.parse_single_example(tfrecord, self.tfrec_format_train)\n",
" X = tf.reshape(tf.io.decode_raw(tensor_dict['wave'], tf.float64), (3, 4096))\n",
" y = tf.reshape(tf.cast(tensor_dict['target'], tf.float32), [1])\n",
" # sample_ids = tensor_dict['sample_id']\n",
" return X, y\n",
"\n",
" def _decode_test(self, tfrecord):\n",
" tensor_dict = tf.io.parse_single_example(tfrecord, self.tfrec_format_test)\n",
" X = tf.reshape(tf.io.decode_raw(tensor_dict['wave'], tf.float64), (3, 4096))\n",
" return X\n",
"\n",
" def get_dataset(self, train_or_test=True, shuffle=True, file_indices=None):\n",
" data_files = self.train_files if train_or_test else self.test_files\n",
" if file_indices is not None:\n",
" data_files = [data_files[i] for i in file_indices]\n",
" ds = tf.data.TFRecordDataset( # do not interleave test data files with parallel reads\n",
" data_files, num_parallel_reads=self.AUTO if train_or_test else 1, compression_type=\"GZIP\")\n",
" if shuffle:\n",
" options = tf.data.Options()\n",
" options.experimental_deterministic = False\n",
" ds = ds.shuffle(self.config.shuffle_buf_size).with_options(options)\n",
" ds = ds.map(self._decode_train if train_or_test else self._decode_test, num_parallel_calls=self.AUTO)\n",
" ds = ds.batch(self.config.batch_size).map(self._preprocess_wrapper(train_or_test), num_parallel_calls=self.AUTO)\n",
" ds = ds.prefetch(self.AUTO)\n",
" return ds\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 2.2 CNN model and GeM layer "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "N7CuG_KcINxq"
},
"outputs": [],
"source": [
"class GeM(keras.layers.Layer):\n",
" def __init__(self, pool_size, p=3, eps=1e-6, **kwargs):\n",
" super(GeM, self).__init__(**kwargs)\n",
" self.pool_size = pool_size\n",
" self.p = p\n",
" self.eps = eps\n",
"\n",
" def call(self, x):\n",
" x = tf.math.maximum(x, self.eps)\n",
" x = tf.pow(x, self.p)\n",
" x = tf.nn.avg_pool(x, self.pool_size, self.pool_size, 'VALID')\n",
" x = tf.pow(x, 1./self.p)\n",
" return x\n",
"\n",
"def get_model():\n",
" \"\"\"\n",
" Modified from\n",
" https://journals.aps.org/prl/pdf/1check0.1103/PhysRevLett.120.141103\n",
" \"\"\"\n",
" model = keras.models.Sequential([\n",
" keras.layers.Conv1D(64, 64, padding='valid', input_shape=(4096, 3)),\n",
" keras.layers.BatchNormalization(),\n",
" keras.layers.Activation(tf.nn.silu),\n",
" \n",
" keras.layers.Conv1D(64, 32, padding='valid'),\n",
" GeM(pool_size=8),\n",
" keras.layers.BatchNormalization(),\n",
" keras.layers.Activation(tf.nn.silu),\n",
"\n",
" keras.layers.Conv1D(128, 32, padding='valid'),\n",
" keras.layers.BatchNormalization(),\n",
" keras.layers.Activation(tf.nn.silu),\n",
" \n",
" keras.layers.Conv1D(128, 16, padding='valid'),\n",
" GeM(pool_size=6),\n",
" keras.layers.BatchNormalization(),\n",
" keras.layers.Activation(tf.nn.silu),\n",
"\n",
" keras.layers.Conv1D(256, 16, padding='valid'),\n",
" keras.layers.BatchNormalization(),\n",
" keras.layers.Activation(tf.nn.silu),\n",
" \n",
" keras.layers.Conv1D(256, 16, padding='valid'),\n",
" GeM(pool_size=4),\n",
" keras.layers.BatchNormalization(),\n",
" keras.layers.Activation(tf.nn.silu),\n",
"\n",
" keras.layers.Flatten(),\n",
" # keras.layers.GlobalAveragePooling1D(),\n",
"\n",
" keras.layers.Dense(64),\n",
" keras.layers.BatchNormalization(),\n",
" keras.layers.Dropout(0.25),\n",
" keras.layers.Activation(tf.nn.silu),\n",
"\n",
" keras.layers.Dense(64),\n",
" keras.layers.BatchNormalization(),\n",
" keras.layers.Dropout(0.25),\n",
" keras.layers.Activation(tf.nn.silu),\n",
"\n",
" keras.layers.Dense(1, activation='sigmoid')\n",
" ])\n",
"\n",
" return model"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 2.3 Training and inference functions "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "yXNvjXOHINxs"
},
"outputs": [],
"source": [
"def seed_all(seed=42):\n",
" np.random.seed(seed)\n",
" tf.random.set_seed(seed)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "8LYpQzubIwkc"
},
"outputs": [],
"source": [
"def get_logger(\n",
" logger_name,\n",
" log_path=None,\n",
" file_level=logging.INFO,\n",
" stream_level=logging.INFO,\n",
"):\n",
" if log_path is None and stream_level is None:\n",
" raise ValueError(\"Both file and stream logger is None.\")\n",
" logger = logging.getLogger(logger_name)\n",
" logger.setLevel(logging.INFO)\n",
" logger_format = logging.Formatter(\"%(asctime)s - %(levelname)s - %(message)s\")\n",
" # Add file handler\n",
" if log_path is not None and Path(log_path).expanduser().resolve().exists():\n",
" logger_file = (\n",
" Path(log_path).expanduser().resolve().joinpath(logger_name + \".log\")\n",
" )\n",
" if logger_file.exists():\n",
" logger_file.unlink()\n",
" fh = logging.FileHandler(logger_file)\n",
" fh.setLevel(file_level)\n",
" fh.setFormatter(logger_format)\n",
" logger.addHandler(fh)\n",
" # Add stream handler\n",
" if stream_level is not None:\n",
" sh = logging.StreamHandler()\n",
" sh.setLevel(stream_level)\n",
" sh.setFormatter(logger_format)\n",
" logger.addHandler(sh)\n",
" return logger\n",
"\n",
"class Config(dict):\n",
" def __init__(self, *args, **kwargs):\n",
" super().__init__(**kwargs)\n",
" self.__dict__ = self\n",
"\n",
"def check_save_config(config: Config):\n",
" config.results_path = str(Path(config.results_parent_path).joinpath(config.name))\n",
" p = Path(config.results_path).expanduser().resolve()\n",
" try:\n",
" p.mkdir(parents=True, exist_ok=False)\n",
" except FileExistsError:\n",
" if any(p.iterdir()):\n",
" raise ValueError(\"Non-empty results directory.\")\n",
" joblib.dump(config, p.joinpath('config.pkl'))\n",
" attrs = {k: v for k, v in vars(config).items() if not k.startswith('__')}\n",
" with open(p.joinpath('config.json'), 'w') as f: # Human readable JSON\n",
" try:\n",
" attrs['filter']['scaling'] = attrs['filter']['scaling'].tolist()\n",
" except AttributeError:\n",
" pass\n",
" json.dump(attrs, f)\n",
"\n",
"def train(config: Config, train_data, val_data, fold_k=None):\n",
" \"\"\"\n",
" Train a single fold of training dataset.\n",
" \"\"\"\n",
" checkpoint_path = Path(config.results_path).joinpath(\n",
" 'checkpoint' + ('' if fold_k is None else f\"_fold{fold_k}\" ))\n",
" step = tf.Variable(0, trainable=False)\n",
" lr_schedule_class = getattr(tf.keras.optimizers.schedules, config.lr_schedule)\n",
" lr_schedule = lr_schedule_class(**config.lr_schedule_paras[config.lr_schedule])\n",
" optimizer_class = getattr(tfa.optimizers, config.optimizer)\n",
" optimizer = optimizer_class(learning_rate=1*lr_schedule(step), **config.optimizer_paras[config.optimizer]) \n",
" # weight_decay = lambda: cfg.optimizer['weight_decay'] * lr_schedule(step))\n",
"\n",
" model = get_model()\n",
" model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=[keras.metrics.AUC(name='AUC')])\n",
" checkpoint_cb = ModelCheckpoint(checkpoint_path, monitor='val_AUC', verbose=0, save_best_only=True, mode='max')\n",
" history = model.fit(train_data, epochs=config.epochs, callbacks=[checkpoint_cb], validation_data=val_data)\n",
" pd.DataFrame(history.history).to_csv(checkpoint_path.joinpath('train_history.csv'))\n",
"\n",
" # return best model and the checkpoint path\n",
" model = keras.models.load_model(checkpoint_path)\n",
" return model, checkpoint_path\n",
"\n",
"def get_score(y_true, y_pred):\n",
" \"\"\"\n",
" Compute ROC AUC score on tensors.\n",
" \"\"\"\n",
" auc = tf.keras.metrics.AUC()\n",
" auc.update_state(y_true, y_pred)\n",
" score = auc.result().numpy()\n",
" return score\n",
"\n",
"def oof_predict(model, val_data):\n",
" \"\"\"\n",
" Predict on the validation dataset of a single fold.\n",
" \"\"\"\n",
" val_y_true = []\n",
" val_y_pred = []\n",
" for X, y in val_data:\n",
" val_y_true.append(y)\n",
" val_y_pred.append(model(X))\n",
" val_y_true = tf.concat(val_y_true, axis=0)\n",
" val_y_pred = tf.concat(val_y_pred, axis=0)\n",
" val_score = get_score(val_y_true, val_y_pred)\n",
" return val_y_true, val_y_pred, val_score\n",
"\n",
"def make_inference(config, models, logger=None):\n",
" \"\"\"\n",
" Make inference on test dataset and create submission file.\n",
" \"\"\"\n",
" logger_func = logger.info if logger else print\n",
" data = Data(config)\n",
" test_data = data.get_dataset(train_or_test=False, shuffle=False)\n",
" test_preds = []\n",
" for k, model in zip(config.train_folds or range(config.K_fold), models):\n",
" logger_func(f\"Make inference by fold {k} model\")\n",
" y_pred = model.predict(test_data)\n",
" test_preds.append(y_pred)\n",
" test_preds = np.concatenate(test_preds, axis=1).mean(axis=1)\n",
" sample = pd.read_csv(config.data_path + 'sample_submission.csv')\n",
" test_preds_df = pd.DataFrame({'id': sample['id'].values, 'target': test_preds})\n",
" p_submission = Path(config.results_path).joinpath(f'{config.name}_submission.csv')\n",
" test_preds_df.to_csv(p_submission, index=False)\n",
" logger_func(f'Test inference written to {p_submission}.')\n",
" return test_preds_df\n",
"\n",
"def train_K_folds_make_inference(config):\n",
" \"\"\"\n",
" Train K folds of the training dataset with out-of-fold validation.\n",
" \"\"\"\n",
" try:\n",
" check_save_config(config)\n",
" except FileExistsError:\n",
" print(f\"Results path: {config.results_path} exists and not empty. Quit.\")\n",
" return\n",
"\n",
" logger = get_logger(config.name, log_path=config.results_path)\n",
" logger.info(f\"{config.description}\")\n",
" logger.info(f\"Results path: {config.results_path}\")\n",
"\n",
" data = Data(config)\n",
" kf = KFold(n_splits=config.K_fold, shuffle=True, random_state=config.seed)\n",
" oof_models, oof_model_paths, oof_labels, oof_preds, k_fold_scores = [], [], [], [], []\n",
" for k, (train_idx, val_idx) in enumerate(kf.split(data.train_files)):\n",
" if config.train_folds and k not in config.train_folds:\n",
" continue\n",
" logger.info(f\"--- Train fold {k} of {config.train_folds} ---\")\n",
" logger.info(f\"Train: {train_idx} Val: {val_idx}\")\n",
" train_data = data.get_dataset(train_or_test=True, shuffle=True, file_indices=train_idx)\n",
" val_data = data.get_dataset(train_or_test=True, shuffle=False, file_indices=val_idx)\n",
" model, model_path = train(config, train_data, val_data, fold_k=k)\n",
" oof_models.append(model)\n",
" oof_model_paths.append(model_path)\n",
" # oof prediction\n",
" val_y_true, val_y_pred, val_score = oof_predict(model, val_data)\n",
" oof_labels.append(val_y_true)\n",
" oof_preds.append(val_y_pred)\n",
" k_fold_scores.append(val_score)\n",
" logger.info(f\"Fold {k} val score: {val_score}\")\n",
" oof_labels = tf.concat(oof_labels, axis=0)\n",
" oof_preds = tf.concat(oof_preds, axis=0)\n",
" oof_score = get_score(oof_labels, oof_preds)\n",
" logger.info(f\"OOF val score: {oof_score}\")\n",
"\n",
" logger.info(\"--- Inference ---\")\n",
" test_preds_df = make_inference(config, oof_models, logger)\n",
" \n",
" return oof_models, oof_model_paths, oof_score, k_fold_scores, test_preds_df\n",
"\n",
"def load_results_make_inference(results_path: str):\n",
" \"\"\"\n",
" Load saved models and make inference on test dataset.\n",
" \"\"\"\n",
" p = Path(results_path).expanduser().resolve()\n",
" if not p.exists():\n",
" print(f\"Invalid results_path: {results_path}\")\n",
" return\n",
" config = joblib.load(p.joinpath('config.pkl'))\n",
" models = []\n",
" for k in config.train_folds or range(config.K_fold):\n",
" checkpoint_k = p.joinpath(f'checkpoint_fold{k}')\n",
" model = keras.models.load_model(checkpoint_k)\n",
" models.append(model)\n",
" test_preds_df = make_inference(config, models)\n",
"\n",
" return test_preds_df"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 3 Configuration "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "ALg4a4g_INxt"
},
"outputs": [],
"source": [
"config = Config(\n",
" name = \"CNN1d_GeM_SGDW_Highpass_Tukey_\" + datetime.now().strftime(\"%Y-%m-%d_%H-%M\"),\n",
" description = \"CNN1d GeM SGDW CosineDecay, 5 folds, 20 epochs, batch_size 128. Highpass signal filter.\",\n",
"\n",
" # paths\n",
" # data_path = \"data/\", # Dataset on local drive\n",
" data_path = \"/content/drive/Shareddrives/ml/g2net/data/\", # Dataset on Google Drive\n",
" # data_path = \"gs://kds-8a5a5ceed201023b7b0d1880950ccc33c21b9bef067a7abe0dfb4aaa/\", # Dataset on Kaggle GCS\n",
" # results_path = \"results/\", # Save results on local drive\n",
" results_parent_path = \"/content/drive/Shareddrives/ml/g2net/results/\", # Save results on Google Drive\n",
" results_path = None, # results_parent_path + name, to be initialized in check_and_save_config().\n",
" shuffle_buf_size = 2048,\n",
"\n",
" # train/test paras\n",
" K_fold = 5,\n",
" train_folds = [], # If not empty, only train a subset of folds.\n",
" batch_size = 128,\n",
" epochs = 20,\n",
"\n",
" # warm start\n",
" warm_start = False,\n",
" warm_start_model_path = \"\",\n",
"\n",
" # algorithm/model paras\n",
" filter = dict(\n",
" scaling = 1e20, # 1 / np.array([1.5e-20, 1.5e-20, 0.5e-20]).reshape(-1, 1),\n",
" #filter_type = 'bandpass', filter_order=8, f_lo=25, f_hi=1000, sampling_rate=2048\n",
" filter_type='highpass', filter_order=5, f_lo=20.43, f_hi=None, sampling_rate=2048\n",
" ),\n",
" lr_schedule = 'CosineDecay',\n",
" lr_schedule_paras = {'CosineDecay': dict(initial_learning_rate=1e-1, decay_steps=5, alpha=1e-6)}, # init_lr=eta_max alpha= eta_min/eta_max\n",
" optimizer = 'SGDW',\n",
" optimizer_paras = {\n",
" 'SGDW': dict(weight_decay=1e-4, momentum=0.9, nesterov=True),\n",
" 'AdamW': dict(weight_decay=1e-5),\n",
" },\n",
"\n",
" # misc\n",
" seed = 42,\n",
")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 4 Run training and inference "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "IxFVT2a4Ba_B",
"outputId": "5b1c045d-126f-40e3-8323-9a01329ae443"
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-01-30 19:27:25,667 - INFO - CNN1d GeM SGDW CosineDecay, 5 folds, 20 epochs, batch_size 128. Highpass signal filter.\n",
"2022-01-30 19:27:25,669 - INFO - Results path: /content/drive/Shareddrives/ml/g2net/results/CNN1d_GeM_SGDW_Highpass_Tukey_2022-01-30_19-27\n",
"2022-01-30 19:27:25,679 - INFO - --- Train fold 0 of [] ---\n",
"2022-01-30 19:27:25,681 - INFO - Train: [ 2 3 4 5 6 7 8 9 10 11 12 13 14 16 18 19] Val: [ 0 1 15 17]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch 1/20\n",
"3500/3500 [==============================] - 625s 172ms/step - loss: 0.4740 - AUC: 0.8321 - val_loss: 0.4502 - val_AUC: 0.8599\n",
"Epoch 2/20\n",
"3500/3500 [==============================] - 612s 173ms/step - loss: 0.4322 - AUC: 0.8590 - val_loss: 0.4582 - val_AUC: 0.8628\n",
"Epoch 3/20\n",
"3500/3500 [==============================] - 608s 171ms/step - loss: 0.4257 - AUC: 0.8627 - val_loss: 0.4280 - val_AUC: 0.8661\n",
"Epoch 4/20\n",
"3500/3500 [==============================] - 598s 169ms/step - loss: 0.4229 - AUC: 0.8641 - val_loss: 0.4277 - val_AUC: 0.8624\n",
"Epoch 5/20\n",
"3500/3500 [==============================] - 605s 171ms/step - loss: 0.4211 - AUC: 0.8651 - val_loss: 0.4197 - val_AUC: 0.8676\n",
"Epoch 6/20\n",
"3500/3500 [==============================] - 604s 170ms/step - loss: 0.4195 - AUC: 0.8659 - val_loss: 0.4254 - val_AUC: 0.8630\n",
"Epoch 7/20\n",
"3500/3500 [==============================] - 618s 172ms/step - loss: 0.4178 - AUC: 0.8667 - val_loss: 0.4188 - val_AUC: 0.8671\n",
"Epoch 8/20\n",
"3500/3500 [==============================] - 610s 170ms/step - loss: 0.4166 - AUC: 0.8675 - val_loss: 0.4256 - val_AUC: 0.8667\n",
"Epoch 9/20\n",
"3500/3500 [==============================] - 620s 173ms/step - loss: 0.4149 - AUC: 0.8684 - val_loss: 0.4409 - val_AUC: 0.8673\n",
"Epoch 10/20\n",
"3500/3500 [==============================] - 619s 172ms/step - loss: 0.4144 - AUC: 0.8687 - val_loss: 0.4260 - val_AUC: 0.8651\n",
"Epoch 11/20\n",
"3500/3500 [==============================] - 614s 171ms/step - loss: 0.4130 - AUC: 0.8696 - val_loss: 0.4187 - val_AUC: 0.8682\n",
"Epoch 12/20\n",
"3500/3500 [==============================] - 608s 171ms/step - loss: 0.4124 - AUC: 0.8700 - val_loss: 0.4297 - val_AUC: 0.8666\n",
"Epoch 13/20\n",
"3500/3500 [==============================] - 599s 169ms/step - loss: 0.4110 - AUC: 0.8706 - val_loss: 0.4715 - val_AUC: 0.8671\n",
"Epoch 14/20\n",
"3500/3500 [==============================] - 622s 173ms/step - loss: 0.4106 - AUC: 0.8711 - val_loss: 0.4368 - val_AUC: 0.8645\n",
"Epoch 15/20\n",
"3500/3500 [==============================] - 622s 172ms/step - loss: 0.4095 - AUC: 0.8716 - val_loss: 0.4294 - val_AUC: 0.8662\n",
"Epoch 16/20\n",
"3500/3500 [==============================] - 612s 171ms/step - loss: 0.4090 - AUC: 0.8720 - val_loss: 0.4366 - val_AUC: 0.8622\n",
"Epoch 17/20\n",
"3500/3500 [==============================] - 609s 172ms/step - loss: 0.4080 - AUC: 0.8726 - val_loss: 0.4547 - val_AUC: 0.8636\n",
"Epoch 18/20\n",
"3500/3500 [==============================] - 610s 171ms/step - loss: 0.4075 - AUC: 0.8728 - val_loss: 0.4235 - val_AUC: 0.8666\n",
"Epoch 19/20\n",
"3500/3500 [==============================] - 618s 173ms/step - loss: 0.4063 - AUC: 0.8738 - val_loss: 0.4486 - val_AUC: 0.8659\n",
"Epoch 20/20\n",
"3500/3500 [==============================] - 620s 173ms/step - loss: 0.4059 - AUC: 0.8741 - val_loss: 0.4653 - val_AUC: 0.8636\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-01-30 22:54:05,364 - INFO - Fold 0 val score: 0.8681674599647522\n",
"2022-01-30 22:54:05,366 - INFO - --- Train fold 1 of [] ---\n",
"2022-01-30 22:54:05,367 - INFO - Train: [ 0 1 2 4 6 7 9 10 12 13 14 15 16 17 18 19] Val: [ 3 5 8 11]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch 1/20\n",
"3500/3500 [==============================] - 604s 170ms/step - loss: 0.4752 - AUC: 0.8316 - val_loss: 0.4422 - val_AUC: 0.8604\n",
"Epoch 2/20\n",
"3500/3500 [==============================] - 612s 173ms/step - loss: 0.4311 - AUC: 0.8596 - val_loss: 0.4472 - val_AUC: 0.8658\n",
"Epoch 3/20\n",
"3500/3500 [==============================] - 605s 171ms/step - loss: 0.4241 - AUC: 0.8635 - val_loss: 0.4904 - val_AUC: 0.8635\n",
"Epoch 4/20\n",
"3500/3500 [==============================] - 604s 170ms/step - loss: 0.4210 - AUC: 0.8653 - val_loss: 0.4232 - val_AUC: 0.8658\n",
"Epoch 5/20\n",
"3500/3500 [==============================] - 607s 171ms/step - loss: 0.4196 - AUC: 0.8659 - val_loss: 0.4295 - val_AUC: 0.8608\n",
"Epoch 6/20\n",
"3500/3500 [==============================] - 608s 170ms/step - loss: 0.4177 - AUC: 0.8671 - val_loss: 0.4510 - val_AUC: 0.8658\n",
"Epoch 7/20\n",
"3500/3500 [==============================] - 597s 169ms/step - loss: 0.4164 - AUC: 0.8676 - val_loss: 0.4249 - val_AUC: 0.8650\n",
"Epoch 8/20\n",
"3500/3500 [==============================] - 627s 175ms/step - loss: 0.4148 - AUC: 0.8687 - val_loss: 0.4341 - val_AUC: 0.8660\n",
"Epoch 9/20\n",
"3500/3500 [==============================] - 612s 173ms/step - loss: 0.4138 - AUC: 0.8691 - val_loss: 0.4255 - val_AUC: 0.8667\n",
"Epoch 10/20\n",
"3500/3500 [==============================] - 615s 173ms/step - loss: 0.4139 - AUC: 0.8691 - val_loss: 0.4178 - val_AUC: 0.8670\n",
"Epoch 11/20\n",
"3500/3500 [==============================] - 610s 171ms/step - loss: 0.4122 - AUC: 0.8703 - val_loss: 0.4198 - val_AUC: 0.8665\n",
"Epoch 12/20\n",
"3500/3500 [==============================] - 619s 173ms/step - loss: 0.4114 - AUC: 0.8705 - val_loss: 0.4341 - val_AUC: 0.8652\n",
"Epoch 13/20\n",
"3500/3500 [==============================] - 609s 170ms/step - loss: 0.4105 - AUC: 0.8712 - val_loss: 0.4316 - val_AUC: 0.8631\n",
"Epoch 14/20\n",
"3500/3500 [==============================] - 619s 173ms/step - loss: 0.4093 - AUC: 0.8719 - val_loss: 0.4198 - val_AUC: 0.8658\n",
"Epoch 15/20\n",
"3500/3500 [==============================] - 618s 172ms/step - loss: 0.4084 - AUC: 0.8723 - val_loss: 0.4241 - val_AUC: 0.8633\n",
"Epoch 16/20\n",
"3500/3500 [==============================] - 607s 171ms/step - loss: 0.4068 - AUC: 0.8735 - val_loss: 0.4319 - val_AUC: 0.8656\n",
"Epoch 17/20\n",
"3500/3500 [==============================] - 622s 174ms/step - loss: 0.4065 - AUC: 0.8737 - val_loss: 0.4347 - val_AUC: 0.8622\n",
"Epoch 18/20\n",
"3500/3500 [==============================] - 616s 171ms/step - loss: 0.4060 - AUC: 0.8741 - val_loss: 0.4223 - val_AUC: 0.8638\n",
"Epoch 19/20\n",
"3500/3500 [==============================] - 620s 172ms/step - loss: 0.4046 - AUC: 0.8747 - val_loss: 0.4300 - val_AUC: 0.8623\n",
"Epoch 20/20\n",
"3500/3500 [==============================] - 620s 173ms/step - loss: 0.4037 - AUC: 0.8755 - val_loss: 0.4542 - val_AUC: 0.8624\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-01-31 02:20:40,964 - INFO - Fold 1 val score: 0.8670347332954407\n",
"2022-01-31 02:20:40,966 - INFO - --- Train fold 2 of [] ---\n",
"2022-01-31 02:20:40,969 - INFO - Train: [ 0 1 3 4 5 6 7 8 9 10 11 12 14 15 17 19] Val: [ 2 13 16 18]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch 1/20\n",
"3500/3500 [==============================] - 604s 170ms/step - loss: 0.4754 - AUC: 0.8316 - val_loss: 0.4662 - val_AUC: 0.8558\n",
"Epoch 2/20\n",
"3500/3500 [==============================] - 611s 173ms/step - loss: 0.4314 - AUC: 0.8595 - val_loss: 0.4310 - val_AUC: 0.8614\n",
"Epoch 3/20\n",
"3500/3500 [==============================] - 613s 173ms/step - loss: 0.4251 - AUC: 0.8634 - val_loss: 0.4602 - val_AUC: 0.8623\n",
"Epoch 4/20\n",
"3500/3500 [==============================] - 611s 172ms/step - loss: 0.4218 - AUC: 0.8651 - val_loss: 0.4296 - val_AUC: 0.8636\n",
"Epoch 5/20\n",
"3500/3500 [==============================] - 614s 173ms/step - loss: 0.4199 - AUC: 0.8659 - val_loss: 0.4305 - val_AUC: 0.8655\n",
"Epoch 6/20\n",
"3500/3500 [==============================] - 606s 172ms/step - loss: 0.4183 - AUC: 0.8670 - val_loss: 0.4425 - val_AUC: 0.8656\n",
"Epoch 7/20\n",
"3500/3500 [==============================] - 611s 172ms/step - loss: 0.4164 - AUC: 0.8679 - val_loss: 0.4205 - val_AUC: 0.8660\n",
"Epoch 8/20\n",
"3500/3500 [==============================] - 607s 171ms/step - loss: 0.4150 - AUC: 0.8686 - val_loss: 0.4361 - val_AUC: 0.8645\n",
"Epoch 9/20\n",
"3500/3500 [==============================] - 617s 173ms/step - loss: 0.4135 - AUC: 0.8695 - val_loss: 0.4256 - val_AUC: 0.8636\n",
"Epoch 10/20\n",
"3500/3500 [==============================] - 621s 173ms/step - loss: 0.4127 - AUC: 0.8700 - val_loss: 0.4539 - val_AUC: 0.8640\n",
"Epoch 11/20\n",
"3500/3500 [==============================] - 610s 171ms/step - loss: 0.4114 - AUC: 0.8706 - val_loss: 0.4280 - val_AUC: 0.8637\n",
"Epoch 12/20\n",
"3500/3500 [==============================] - 609s 171ms/step - loss: 0.4102 - AUC: 0.8714 - val_loss: 0.4226 - val_AUC: 0.8641\n",
"Epoch 13/20\n",
"3500/3500 [==============================] - 621s 173ms/step - loss: 0.4094 - AUC: 0.8721 - val_loss: 0.4301 - val_AUC: 0.8617\n",
"Epoch 14/20\n",
"3500/3500 [==============================] - 618s 172ms/step - loss: 0.4088 - AUC: 0.8725 - val_loss: 0.4680 - val_AUC: 0.8651\n",
"Epoch 15/20\n",
"3500/3500 [==============================] - 626s 175ms/step - loss: 0.4077 - AUC: 0.8730 - val_loss: 0.4276 - val_AUC: 0.8618\n",
"Epoch 16/20\n",
"3500/3500 [==============================] - 601s 169ms/step - loss: 0.4068 - AUC: 0.8736 - val_loss: 0.4408 - val_AUC: 0.8635\n",
"Epoch 17/20\n",
"3500/3500 [==============================] - 624s 173ms/step - loss: 0.4062 - AUC: 0.8738 - val_loss: 0.4522 - val_AUC: 0.8636\n",
"Epoch 18/20\n",
"3500/3500 [==============================] - 616s 171ms/step - loss: 0.4052 - AUC: 0.8748 - val_loss: 0.4287 - val_AUC: 0.8605\n",
"Epoch 19/20\n",
"3500/3500 [==============================] - 620s 173ms/step - loss: 0.4041 - AUC: 0.8755 - val_loss: 0.4273 - val_AUC: 0.8612\n",
"Epoch 20/20\n",
"3500/3500 [==============================] - 621s 173ms/step - loss: 0.4031 - AUC: 0.8760 - val_loss: 0.4274 - val_AUC: 0.8602\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-01-31 05:48:19,458 - INFO - Fold 2 val score: 0.8660010099411011\n",
"2022-01-31 05:48:19,460 - INFO - --- Train fold 3 of [] ---\n",
"2022-01-31 05:48:19,463 - INFO - Train: [ 0 1 2 3 5 6 7 8 10 11 13 14 15 16 17 18] Val: [ 4 9 12 19]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch 1/20\n",
"3500/3500 [==============================] - 607s 171ms/step - loss: 0.4695 - AUC: 0.8358 - val_loss: 0.4535 - val_AUC: 0.8583\n",
"Epoch 2/20\n",
"3500/3500 [==============================] - 605s 171ms/step - loss: 0.4316 - AUC: 0.8594 - val_loss: 0.4634 - val_AUC: 0.8637\n",
"Epoch 3/20\n",
"3500/3500 [==============================] - 612s 172ms/step - loss: 0.4251 - AUC: 0.8632 - val_loss: 0.4417 - val_AUC: 0.8651\n",
"Epoch 4/20\n",
"3500/3500 [==============================] - 607s 171ms/step - loss: 0.4220 - AUC: 0.8647 - val_loss: 0.4680 - val_AUC: 0.8643\n",
"Epoch 5/20\n",
"3500/3500 [==============================] - 617s 173ms/step - loss: 0.4202 - AUC: 0.8660 - val_loss: 0.4536 - val_AUC: 0.8662\n",
"Epoch 6/20\n",
"3500/3500 [==============================] - 604s 171ms/step - loss: 0.4184 - AUC: 0.8669 - val_loss: 0.4892 - val_AUC: 0.8671\n",
"Epoch 7/20\n",
"3500/3500 [==============================] - 608s 171ms/step - loss: 0.4173 - AUC: 0.8672 - val_loss: 0.4187 - val_AUC: 0.8659\n",
"Epoch 8/20\n",
"3500/3500 [==============================] - 628s 175ms/step - loss: 0.4158 - AUC: 0.8679 - val_loss: 0.4420 - val_AUC: 0.8674\n",
"Epoch 9/20\n",
"3500/3500 [==============================] - 608s 172ms/step - loss: 0.4147 - AUC: 0.8688 - val_loss: 0.4349 - val_AUC: 0.8667\n",
"Epoch 10/20\n",
"3500/3500 [==============================] - 620s 174ms/step - loss: 0.4136 - AUC: 0.8692 - val_loss: 0.4261 - val_AUC: 0.8641\n",
"Epoch 11/20\n",
"3500/3500 [==============================] - 627s 174ms/step - loss: 0.4127 - AUC: 0.8698 - val_loss: 0.4548 - val_AUC: 0.8661\n",
"Epoch 12/20\n",
"3500/3500 [==============================] - 611s 171ms/step - loss: 0.4118 - AUC: 0.8703 - val_loss: 0.4791 - val_AUC: 0.8664\n",
"Epoch 13/20\n",
"3500/3500 [==============================] - 611s 171ms/step - loss: 0.4107 - AUC: 0.8708 - val_loss: 0.4350 - val_AUC: 0.8666\n",
"Epoch 14/20\n",
"3500/3500 [==============================] - 624s 174ms/step - loss: 0.4101 - AUC: 0.8716 - val_loss: 0.4786 - val_AUC: 0.8667\n",
"Epoch 15/20\n",
"3500/3500 [==============================] - 618s 174ms/step - loss: 0.4087 - AUC: 0.8723 - val_loss: 0.4370 - val_AUC: 0.8639\n",
"Epoch 16/20\n",
"3500/3500 [==============================] - 624s 175ms/step - loss: 0.4078 - AUC: 0.8728 - val_loss: 0.4253 - val_AUC: 0.8658\n",
"Epoch 17/20\n",
"3500/3500 [==============================] - 607s 170ms/step - loss: 0.4068 - AUC: 0.8735 - val_loss: 0.4764 - val_AUC: 0.8616\n",
"Epoch 18/20\n",
"3500/3500 [==============================] - 619s 172ms/step - loss: 0.4060 - AUC: 0.8740 - val_loss: 0.4439 - val_AUC: 0.8658\n",
"Epoch 19/20\n",
"3500/3500 [==============================] - 620s 173ms/step - loss: 0.4053 - AUC: 0.8745 - val_loss: 0.4516 - val_AUC: 0.8640\n",
"Epoch 20/20\n",
"3500/3500 [==============================] - 618s 172ms/step - loss: 0.4040 - AUC: 0.8753 - val_loss: 0.4674 - val_AUC: 0.8627\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-01-31 09:15:08,523 - INFO - Fold 3 val score: 0.8674059510231018\n",
"2022-01-31 09:15:08,525 - INFO - --- Train fold 4 of [] ---\n",
"2022-01-31 09:15:08,528 - INFO - Train: [ 0 1 2 3 4 5 8 9 11 12 13 15 16 17 18 19] Val: [ 6 7 10 14]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch 1/20\n",
"3500/3500 [==============================] - 603s 170ms/step - loss: 0.4783 - AUC: 0.8291 - val_loss: 0.4422 - val_AUC: 0.8587\n",
"Epoch 2/20\n",
"3500/3500 [==============================] - 612s 172ms/step - loss: 0.4315 - AUC: 0.8593 - val_loss: 0.4293 - val_AUC: 0.8632\n",
"Epoch 3/20\n",
"3500/3500 [==============================] - 607s 170ms/step - loss: 0.4249 - AUC: 0.8630 - val_loss: 0.4649 - val_AUC: 0.8630\n",
"Epoch 4/20\n",
"3500/3500 [==============================] - 609s 172ms/step - loss: 0.4221 - AUC: 0.8647 - val_loss: 0.4293 - val_AUC: 0.8640\n",
"Epoch 5/20\n",
"3500/3500 [==============================] - 613s 172ms/step - loss: 0.4198 - AUC: 0.8659 - val_loss: 0.4277 - val_AUC: 0.8644\n",
"Epoch 6/20\n",
"3500/3500 [==============================] - 610s 172ms/step - loss: 0.4178 - AUC: 0.8669 - val_loss: 0.4236 - val_AUC: 0.8657\n",
"Epoch 7/20\n",
"3500/3500 [==============================] - 614s 173ms/step - loss: 0.4163 - AUC: 0.8677 - val_loss: 0.4194 - val_AUC: 0.8665\n",
"Epoch 8/20\n",
"3500/3500 [==============================] - 618s 174ms/step - loss: 0.4151 - AUC: 0.8683 - val_loss: 0.4231 - val_AUC: 0.8673\n",
"Epoch 9/20\n",
"3500/3500 [==============================] - 600s 170ms/step - loss: 0.4141 - AUC: 0.8691 - val_loss: 0.4441 - val_AUC: 0.8636\n",
"Epoch 10/20\n",
"3500/3500 [==============================] - 620s 174ms/step - loss: 0.4129 - AUC: 0.8698 - val_loss: 0.4493 - val_AUC: 0.8645\n",
"Epoch 11/20\n",
"3500/3500 [==============================] - 620s 173ms/step - loss: 0.4117 - AUC: 0.8705 - val_loss: 0.4606 - val_AUC: 0.8635\n",
"Epoch 12/20\n",
"3500/3500 [==============================] - 617s 170ms/step - loss: 0.4109 - AUC: 0.8709 - val_loss: 0.4263 - val_AUC: 0.8660\n",
"Epoch 13/20\n",
"3500/3500 [==============================] - 605s 170ms/step - loss: 0.4100 - AUC: 0.8714 - val_loss: 0.4198 - val_AUC: 0.8659\n",
"Epoch 14/20\n",
"3500/3500 [==============================] - 618s 171ms/step - loss: 0.4095 - AUC: 0.8717 - val_loss: 0.4236 - val_AUC: 0.8636\n",
"Epoch 15/20\n",
"3500/3500 [==============================] - 619s 172ms/step - loss: 0.4084 - AUC: 0.8724 - val_loss: 0.4245 - val_AUC: 0.8637\n",
"Epoch 16/20\n",
"3500/3500 [==============================] - 622s 173ms/step - loss: 0.4074 - AUC: 0.8729 - val_loss: 0.4292 - val_AUC: 0.8620\n",
"Epoch 17/20\n",
"3500/3500 [==============================] - 619s 172ms/step - loss: 0.4062 - AUC: 0.8738 - val_loss: 0.4322 - val_AUC: 0.8611\n",
"Epoch 18/20\n",
"3500/3500 [==============================] - 611s 170ms/step - loss: 0.4054 - AUC: 0.8743 - val_loss: 0.4200 - val_AUC: 0.8654\n",
"Epoch 19/20\n",
"3500/3500 [==============================] - 617s 172ms/step - loss: 0.4047 - AUC: 0.8750 - val_loss: 0.4242 - val_AUC: 0.8629\n",
"Epoch 20/20\n",
"3500/3500 [==============================] - 619s 172ms/step - loss: 0.4029 - AUC: 0.8761 - val_loss: 0.4453 - val_AUC: 0.8634\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-01-31 12:41:49,536 - INFO - Fold 4 val score: 0.867283284664154\n",
"2022-01-31 12:41:49,572 - INFO - OOF val score: 0.863306999206543\n",
"2022-01-31 12:41:49,573 - INFO - --- Inference ---\n",
"2022-01-31 12:41:49,743 - INFO - Make inference by fold 0 model\n",
"2022-01-31 12:45:37,653 - INFO - Make inference by fold 1 model\n",
"2022-01-31 12:49:15,957 - INFO - Make inference by fold 2 model\n",
"2022-01-31 12:53:03,120 - INFO - Make inference by fold 3 model\n",
"2022-01-31 12:56:50,739 - INFO - Make inference by fold 4 model\n",
"2022-01-31 13:00:39,477 - INFO - Test inference written to /content/drive/Shareddrives/ml/g2net/results/CNN1d_GeM_SGDW_Highpass_Tukey_2022-01-30_19-27/CNN1d_GeM_SGDW_Highpass_Tukey_2022-01-30_19-27_submission.csv.\n"
]
}
],
"source": [
"oof_models, oof_model_paths, oof_score, k_fold_scores, test_preds_df = train_K_folds_make_inference(config)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Submission to Kaggle\n",
"Private Score: 0.87249 Public score: 0.87414"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "vsWyHCCVGi6Q"
},
"source": [
"# 5 Offline inference from multiple runs of folds \n",
"Colab has running time limits so have to run multiple folds separately."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "UfHQHAm3EZYO"
},
"outputs": [],
"source": [
"#results_path = \"/content/drive/Shareddrives/ml/g2net/results/CNN1d_GeM_SGDW_Highpass_Tukey\"\n",
"#test_preds_df = load_results_make_inference(results_path)"
]
}
],
"metadata": {
"accelerator": "GPU",
"colab": {
"collapsed_sections": [],
"machine_shape": "hm",
"name": "Copy of G2Net_CNN1D_GeM_SGDW_Highpass",
"provenance": []
},
"kernelspec": {
"display_name": "Python 3",
"name": "python3"
},
"language_info": {
"name": "python"
}
},
"nbformat": 4,
"nbformat_minor": 0
}