|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
import pickle |
|
from pathlib import Path |
|
from typing import Any, Callable, Dict, List, Optional, Tuple, Union |
|
|
|
import datasets |
|
import numpy as np |
|
import torch |
|
from sklearn.metrics import roc_auc_score |
|
from torch.utils.data.dataloader import default_collate |
|
|
|
|
|
def pad_collate_fn( |
|
batch: List[Tuple[torch.Tensor, Any]], |
|
batch_first: bool = True, |
|
max_len: Optional[int] = None, |
|
) -> Tuple[torch.Tensor, torch.BoolTensor, Any]: |
|
"""Pad together sequences of arbitrary lengths. |
|
Add a mask of the padding to the samples that can later be used |
|
to ignore padding in activation functions. |
|
|
|
Expected to be used in combination of a torch.utils.datasets.DataLoader. |
|
|
|
Expect the sequences to be padded to be the first one in the sample tuples. |
|
Others members will be batched using ``torch.utils.data.dataloader.default_collate``. |
|
|
|
Parameters |
|
---------- |
|
batch: List[Tuple[torch.Tensor, Any]] |
|
List of tuples (features, Any). Features have shape (N_slides_tiles, F) |
|
with ``N_slides_tiles`` being specific to each slide depending on the |
|
number of extractable tiles in the tissue matter. ``F`` is the feature |
|
extractor output dimension. |
|
batch_first: bool = True |
|
Either return (B, N_TILES, F) or (N_TILES, B, F) |
|
max_len: Optional[int] = None |
|
Pre-defined maximum length for elements inside a batch. |
|
|
|
Returns |
|
------- |
|
padded_sequences, masks, Any: Tuple[torch.Tensor, torch.BoolTensor, Any] |
|
- if batch_first: Tuple[(B, N_TILES, F), (B, N_TILES, 1), ...] |
|
- else: Tuple[(N_TILES, B, F), (N_TILES, B, 1), ...] |
|
|
|
with N_TILES = max_len if max_len is not None |
|
or N_TILES = max length of the training samples. |
|
|
|
""" |
|
|
|
sequences = [] |
|
others = [] |
|
for sample in batch: |
|
sequences.append(sample[0]) |
|
others.append(sample[1:]) |
|
|
|
if max_len is None: |
|
max_len = max([s.size(0) for s in sequences]) |
|
|
|
trailing_dims = sequences[0].size()[1:] |
|
|
|
if batch_first: |
|
padded_dims = (len(sequences), max_len) + trailing_dims |
|
masks_dims = (len(sequences), max_len, 1) |
|
else: |
|
padded_dims = (max_len, len(sequences)) + trailing_dims |
|
masks_dims = (max_len, len(sequences), 1) |
|
|
|
padded_sequences = sequences[0].data.new(*padded_dims).fill_(0.0) |
|
masks = torch.ones(*masks_dims, dtype=torch.bool) |
|
|
|
for i, tensor in enumerate(sequences): |
|
length = tensor.size(0) |
|
|
|
if batch_first: |
|
padded_sequences[i, :length, ...] = tensor[:max_len, ...] |
|
masks[i, :length, ...] = False |
|
else: |
|
padded_sequences[:length, i, ...] = tensor[:max_len, ...] |
|
masks[:length, i, ...] = False |
|
|
|
|
|
others = default_collate(others) |
|
|
|
return (padded_sequences, masks, *others) |
|
|
|
|
|
def auc(labels: np.array, logits: np.array) -> float: |
|
"""ROC AUC score for binary classification. |
|
Parameters |
|
---------- |
|
labels: np.array |
|
Labels of the outcome. |
|
logits: np.array |
|
Probabilities. |
|
""" |
|
preds = 1.0 / (1.0 + np.exp(-logits)) |
|
return roc_auc_score(labels, preds) |
|
|
|
|
|
def get_cv_metrics( |
|
cv_metrics: List[Dict[str, float]], epoch: int = -1 |
|
) -> Dict[str, float]: |
|
"""Get mean and std from cross-validation metrics at a given epoch.""" |
|
cv_mean_metrics = {} |
|
metrics_names = cv_metrics[0].keys() |
|
for m_name in metrics_names: |
|
values = [fold_metrics[m_name][epoch] for fold_metrics in cv_metrics] |
|
mean_metric, std_metric = np.mean(values), np.std(values) |
|
cv_mean_metrics[m_name] = f"{mean_metric:.4f} ± {std_metric:.4f}" |
|
return cv_mean_metrics |
|
|
