mltrainer 0.1.0__py3-none-any.whl

mltrainer/__init__.py

@@ -0,0 +1,6 @@
+from deeptoolkit.trainer import Trainer
+from deeptoolkit.settings import TrainerSettings, ReportTypes
+
+__all__ = ["Trainer", "TrainerSettings", "ReportTypes"]
+
+__version__ = "0.1.0"

mltrainer/imagemodels.py

@@ -0,0 +1,56 @@
+import gin
+import torch
+from torch import nn
+
+
+@gin.configurable
+class NeuralNetwork(nn.Module):
+    def __init__(self, num_classes: int, units1: int, units2: int) -> None:
+        super().__init__()
+        self.flatten = nn.Flatten()
+        self.linear_relu_stack = nn.Sequential(
+            nn.Linear(28 * 28, units1),
+            nn.ReLU(),
+            nn.Linear(units1, units2),
+            nn.ReLU(),
+            nn.Linear(units2, num_classes),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.flatten(x)
+        logits = self.linear_relu_stack(x)
+        return logits
+
+
+@gin.configurable
+class CNN(nn.Module):
+    def __init__(
+        self, num_classes: int, kernel_size: int, filter1: int, filter2: int
+    ) -> None:
+        super().__init__()
+
+        self.convolutions = nn.Sequential(
+            nn.Conv2d(1, filter1, kernel_size=kernel_size, stride=1, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2),
+            nn.Conv2d(filter1, filter2, kernel_size=kernel_size, stride=1, padding=0),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2),
+            nn.Conv2d(filter2, 32, kernel_size=kernel_size, stride=1, padding=0),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2),
+        )
+
+        self.dense = nn.Sequential(
+            nn.Flatten(),
+            nn.Linear(128, 64),
+            nn.ReLU(),
+            nn.Linear(64, 32),
+            nn.ReLU(),
+            nn.Linear(32, num_classes),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.convolutions(x)
+        logits = self.dense(x)
+        return logits

mltrainer/metrics.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from typing import Iterator
+
+import torch
+
+Tensor = torch.Tensor
+
+
+class Metric:
+    def __repr__(self) -> str:
+        raise NotImplementedError
+
+    def __call__(self, y: Tensor, yhat: Tensor) -> Tensor:
+        raise NotImplementedError
+
+
+class MASE(Metric):
+    def __init__(self, train: Iterator, horizon: int) -> None:
+        self.scale = self.naivenorm(train, horizon)
+
+    def __repr__(self) -> str:
+        return f"MASE(scale={self.scale:.3f})"
+
+    def naivenorm(self, train: Iterator, horizon: int) -> Tensor:
+        elist = []
+        # TODO fix ignore
+        streamer = train.stream()  # type: ignore
+        for _ in range(len(train)):  # type: ignore
+            x, y = next(iter(streamer))
+            yhat = self.naivepredict(x, horizon)
+            e = self.mae(y, yhat)
+            elist.append(e)
+        return torch.mean(torch.tensor(elist))
+
+    def naivepredict(self, x: Tensor, horizon: int) -> Tensor:
+        assert horizon > 0
+        yhat = x[..., -horizon:, :].squeeze(-1)
+        return yhat
+
+    def mae(self, y: Tensor, yhat: Tensor) -> Tensor:
+        return torch.mean(torch.abs(y - yhat))
+
+    def __call__(self, y: Tensor, yhat: Tensor) -> Tensor:
+        return self.mae(y, yhat) / self.scale
+
+
+class MAE(Metric):
+    def __repr__(self) -> str:
+        return "MAE"
+
+    def __call__(self, y: Tensor, yhat: Tensor) -> Tensor:
+        return torch.mean(torch.abs(y - yhat))
+
+
+class Accuracy(Metric):
+    def __repr__(self) -> str:
+        return "Accuracy"
+
+    def __call__(self, y: Tensor, yhat: Tensor) -> Tensor:
+        return (yhat.argmax(dim=1) == y).sum() / len(yhat)

mltrainer/rnn_models.py

@@ -0,0 +1,151 @@
+from typing import Dict
+
+import gin
+import torch
+from torch import nn
+
+Tensor = torch.Tensor
+
+
+class BaseModel(nn.Module):
+    def __init__(self, observations: int, horizon: int) -> None:
+        super().__init__()
+        self.flatten = nn.Flatten()  # we have 3d data, the linear model wants 2D
+        self.linear = nn.Linear(observations, horizon)
+
+    def forward(self, x: Tensor) -> Tensor:
+        x = self.flatten(x)
+        x = self.linear(x)
+        return x
+
+
+@gin.configurable
+class BaseRNN(nn.Module):
+    def __init__(
+        self, input_size: int, hidden_size: int, num_layers: int, horizon: int
+    ) -> None:
+        super().__init__()
+        self.rnn = nn.RNN(
+            input_size=input_size,
+            hidden_size=hidden_size,
+            batch_first=True,
+            num_layers=num_layers,
+        )
+        self.linear = nn.Linear(hidden_size, horizon)
+        self.horizon = horizon
+
+    def forward(self, x: Tensor) -> Tensor:
+        x, _ = self.rnn(x)
+        last_step = x[:, -1, :]
+        yhat = self.linear(last_step)
+        return yhat
+
+
+@gin.configurable
+class GRUmodel(nn.Module):
+    def __init__(
+        self,
+        config: Dict,
+    ) -> None:
+        super().__init__()
+        self.rnn = nn.GRU(
+            input_size=config["input_size"],
+            hidden_size=config["hidden_size"],
+            dropout=config["dropout"],
+            batch_first=True,
+            num_layers=config["num_layers"],
+        )
+        self.linear = nn.Linear(config["hidden_size"], config["output_size"])
+
+    def forward(self, x: Tensor) -> Tensor:
+        x, _ = self.rnn(x)
+        last_step = x[:, -1, :]
+        yhat = self.linear(last_step)
+        return yhat
+
+
+@gin.configurable
+class AttentionGRU(nn.Module):
+    def __init__(
+        self,
+        config: Dict,
+    ) -> None:
+        super().__init__()
+        self.rnn = nn.GRU(
+            input_size=config["input_size"],
+            hidden_size=config["hidden_size"],
+            dropout=config["dropout"],
+            batch_first=True,
+            num_layers=config["num_layers"],
+        )
+        self.attention = nn.MultiheadAttention(
+            embed_dim=config["hidden_size"],
+            num_heads=4,
+            dropout=config["dropout"],
+            batch_first=True,
+        )
+        self.linear = nn.Linear(config["hidden_size"], config["output_size"])
+
+    def forward(self, x: Tensor) -> Tensor:
+        x, _ = self.rnn(x)
+        x, _ = self.attention(x.clone(), x.clone(), x)
+        last_step = x[:, -1, :]
+        yhat = self.linear(last_step)
+        return yhat
+
+
+@gin.configurable
+class NLPmodel(nn.Module):
+    def __init__(
+        self,
+        config: Dict,
+    ) -> None:
+        super().__init__()
+        self.emb = nn.Embedding(config["vocab"], config["hidden_size"])
+        self.rnn = nn.GRU(
+            input_size=config["hidden_size"],
+            hidden_size=config["hidden_size"],
+            dropout=config["dropout"],
+            batch_first=True,
+            num_layers=config["num_layers"],
+        )
+        self.linear = nn.Linear(config["hidden_size"], config["output_size"])
+
+    def forward(self, x: Tensor) -> Tensor:
+        x = self.emb(x)
+        x, _ = self.rnn(x)
+        last_step = x[:, -1, :]
+        yhat = self.linear(last_step)
+        return yhat
+
+
+@gin.configurable
+class AttentionNLP(nn.Module):
+    def __init__(
+        self,
+        config: Dict,
+    ) -> None:
+        super().__init__()
+        self.emb = nn.Embedding(config["vocab"], config["hidden_size"])
+        self.rnn = nn.GRU(
+            input_size=config["hidden_size"],
+            hidden_size=config["hidden_size"],
+            dropout=config["dropout"],
+            batch_first=True,
+            num_layers=config["num_layers"],
+        )
+        self.attention = nn.MultiheadAttention(
+            embed_dim=config["hidden_size"],
+            num_heads=4,
+            dropout=config["dropout"],
+            batch_first=True,
+        )
+        self.linear = nn.Linear(config["hidden_size"], config["output_size"])
+
+    def forward(self, x: Tensor) -> Tensor:
+        x = self.emb(x)
+        x, _ = self.rnn(x)
+        x, _ = self.attention(x.clone(), x.clone(), x)
+        last_step = x[:, -1, :]
+        yhat = self.linear(last_step)
+        return yhat

mltrainer/settings.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from enum import Enum
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional
+
+from loguru import logger
+from pydantic import BaseModel, root_validator
+
+
+class FileTypes(Enum):
+    JPG = ".jpg"
+    PNG = ".png"
+    TXT = ".txt"
+    ZIP = ".zip"
+    TGZ = ".tgz"
+    TAR = ".tar.gz"
+    GZ = ".gz"
+
+
+class ReportTypes(Enum):
+    GIN = 1
+    TENSORBOARD = 2
+    MLFLOW = 3
+    RAY = 4
+
+
+class FormattedBase(BaseModel):
+    def __str__(self) -> str:
+        return "\n".join(f"{k}: {v}" for k, v in self.__dict__.items())
+
+    def __repr__(self) -> str:
+        return "\n".join(f"{k}: {v}" for k, v in self.__dict__.items())
+
+
+class TrainerSettings(FormattedBase):
+    epochs: int
+    metrics: List[Callable]
+    logdir: Path
+    train_steps: int
+    valid_steps: int
+    reporttypes: List[ReportTypes]
+    optimizer_kwargs: Dict[str, Any] = {"lr": 1e-3, "weight_decay": 1e-5}
+    scheduler_kwargs: Optional[Dict[str, Any]] = {"factor": 0.1, "patience": 10}
+    earlystop_kwargs: Optional[Dict[str, Any]] = {
+        "save": False,
+        "verbose": True,
+        "patience": 10,
+    }
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    @root_validator
+    def check_path(cls, values: Dict) -> Dict:  # noqa: N805
+        datadir = values.get("logdir").resolve()
+        if not datadir.exists():  # type: ignore
+            raise FileNotFoundError(
+                f"Make sure the datadir exists.\n Found {datadir} to be non-existing."
+            )
+        return values

mltrainer/tokenizer.py

@@ -0,0 +1,83 @@
+import re
+import string
+from collections import Counter, OrderedDict
+from typing import Callable, List, Optional, Tuple
+
+import gin
+import torch
+from loguru import logger
+from torch.nn.utils.rnn import pad_sequence
+from torchtext.vocab import Vocab, vocab
+
+Tensor = torch.Tensor
+
+
+def split_and_flat(corpus: List[str]) -> List[str]:
+    corpus_ = [x.split() for x in corpus]
+    corpus = [x for y in corpus_ for x in y]
+    return corpus
+
+
+@gin.configurable
+def build_vocab(
+    corpus: List[str], max: int, oov: str = "<OOV>", pad: str = "<PAD>"
+) -> Vocab:
+    data = split_and_flat(corpus)
+    counter = Counter(data).most_common()
+    logger.info(f"Found {len(counter)} tokens")
+    counter = counter[: max - 2]
+    ordered_dict = OrderedDict(counter)
+    v1 = vocab(ordered_dict, specials=[pad, oov])
+    v1.set_default_index(v1[oov])
+    return v1
+
+
+def tokenize(corpus: List[str], v: Vocab) -> Tensor:
+    batch = []
+    for sent in corpus:
+        batch.append(torch.tensor([v[word] for word in sent.split()]))
+    return pad_sequence(batch, batch_first=True)
+
+
+def clean(text: str) -> str:
+    punctuation = f"[{string.punctuation}]"
+    # remove CaPiTaLs
+    lowercase = text.lower()
+    # change don't and isn't into dont and isnt
+    neg = re.sub("\\'", "", lowercase)
+    # swap html tags for spaces
+    html = re.sub("<br />", " ", neg)
+    # swap punctuation for spaces
+    stripped = re.sub(punctuation, " ", html)
+    # remove extra spaces
+    spaces = re.sub("  +", " ", stripped)
+    return spaces
+
+
+@gin.configurable
+class Preprocessor:
+    def __init__(
+        self, max: int, vocab: Vocab, clean: Optional[Callable] = None
+    ) -> None:
+        self.max = max
+        self.vocab = vocab
+        self.clean = clean
+
+    def cast_label(self, label: str) -> int:
+        if label == "neg":
+            return 0
+        else:
+            return 1
+
+    def __call__(self, batch: List) -> Tuple[Tensor, Tensor]:
+        labels, text = [], []
+        for x, y in batch:
+            if clean is not None:
+                x = self.clean(x)  # type: ignore
+            x = x.split()[: self.max]
+            tokens = torch.tensor([self.vocab[word] for word in x], dtype=torch.int32)
+            text.append(tokens)
+            labels.append(self.cast_label(y))
+
+        text_ = pad_sequence(text, batch_first=True, padding_value=0)
+        return text_, torch.tensor(labels)

mltrainer/trainer.py

@@ -0,0 +1,235 @@
+from datetime import datetime
+from pathlib import Path
+from typing import Callable, Dict, Iterator, Optional, Tuple
+
+import gin
+import mlflow
+# needed to make summarywriter load without error
+import torch
+from loguru import logger
+from ray import tune
+from torch.utils.tensorboard import SummaryWriter
+from tqdm import tqdm
+
+from deeptoolkit.settings import ReportTypes, TrainerSettings
+
+
+def write_gin(dir: Path, txt: str) -> None:
+    path = dir / "saved_config.gin"
+    with open(path, "w") as file:
+        file.write(txt)
+
+
+def dir_add_timestamp(log_dir: Optional[Path] = None) -> Path:
+    if log_dir is None:
+        log_dir = Path(".")
+    log_dir = Path(log_dir)
+    timestamp = datetime.now().strftime("%Y%m%d-%H%M")
+    log_dir = log_dir / timestamp
+    logger.info(f"Logging to {log_dir}")
+    if not log_dir.exists():
+        log_dir.mkdir(parents=True)
+    return log_dir
+
+
+class Trainer:
+    def __init__(
+        self,
+        model: torch.nn.Module,
+        settings: TrainerSettings,
+        loss_fn: Callable,
+        optimizer: torch.optim.Optimizer,
+        traindataloader: Iterator,
+        validdataloader: Iterator,
+        scheduler: Optional[Callable],
+    ) -> None:
+        self.model = model
+        self.settings = settings
+        self.log_dir = dir_add_timestamp(settings.logdir)
+        self.loss_fn = loss_fn
+        self.optimizer = optimizer
+        self.traindataloader = traindataloader
+        self.validdataloader = validdataloader
+
+        self.optimizer = optimizer(  # type: ignore
+            model.parameters(), **settings.optimizer_kwargs
+        )
+        self.last_epoch = 0
+
+        if scheduler:
+            if settings.scheduler_kwargs is None:
+                raise ValueError("Missing 'scheduler_kwargs' in TrainerSettings.")
+            self.scheduler = scheduler(self.optimizer, **settings.scheduler_kwargs)
+
+        if settings.earlystop_kwargs is not None:
+            logger.info(
+                "Found earlystop_kwargs in settings."
+                "Set to None if you dont want earlystopping."
+            )
+            self.early_stopping: Optional[EarlyStopping] = EarlyStopping(
+                self.log_dir, **settings.earlystop_kwargs
+            )
+        else:
+            self.early_stopping = None
+
+        if ReportTypes.TENSORBOARD in self.settings.reporttypes:
+            self.writer = SummaryWriter(log_dir=self.log_dir)
+
+        if ReportTypes.GIN in self.settings.reporttypes:
+            write_gin(self.log_dir, gin.config_str())
+
+    def loop(self) -> None:
+        for epoch in tqdm(range(self.settings.epochs), colour="#1e4706"):
+            train_loss = self.trainbatches()
+            metric_dict, test_loss = self.evalbatches()
+            self.report(epoch, train_loss, test_loss, metric_dict)
+
+            if self.early_stopping:
+                self.early_stopping(test_loss, self.model)  # type: ignore
+
+            if self.early_stopping is not None and self.early_stopping.early_stop:
+                logger.info("Interrupting loop due to early stopping patience.")
+                self.last_epoch = epoch
+                if self.early_stopping.save:
+                    logger.info("retrieving best model.")
+                    self.model = self.early_stopping.get_best()  # type: ignore
+                else:
+                    logger.info(
+                        "early_stopping_save was false, using latest model."
+                        "Set to true to retrieve best model."
+                    )
+                break
+        self.last_epoch = epoch
+
+    def trainbatches(self) -> float:
+        self.model.train()
+        train_loss: float = 0.0
+        train_steps = self.settings.train_steps
+        for _ in tqdm(range(train_steps), colour="#1e4706"):
+            x, y = next(iter(self.traindataloader))
+            self.optimizer.zero_grad()
+            yhat = self.model(x)
+            loss = self.loss_fn(yhat, y)
+            loss.backward()
+            self.optimizer.step()
+            train_loss += loss.detach().numpy()
+        train_loss /= train_steps
+        return train_loss
+
+    def evalbatches(self) -> Tuple[Dict[str, float], float]:
+        self.model.eval()
+        valid_steps = self.settings.valid_steps
+        test_loss: float = 0.0
+        metric_dict: Dict[str, float] = {}
+        for _ in range(valid_steps):
+            x, y = next(iter(self.validdataloader))
+            yhat = self.model(x)
+            test_loss += self.loss_fn(yhat, y).detach().numpy()
+            for m in self.settings.metrics:
+                metric_dict[str(m)] = (
+                    metric_dict.get(str(m), 0.0) + m(y, yhat).detach().numpy()
+                )
+
+        test_loss /= valid_steps
+        for key in metric_dict:
+            metric_dict[str(key)] = metric_dict[str(key)] / valid_steps
+        return metric_dict, test_loss
+
+    def report(
+        self, epoch: int, train_loss: float, test_loss: float, metric_dict: Dict
+    ) -> None:
+        epoch = epoch + self.last_epoch
+        reporttypes = self.settings.reporttypes
+        self.test_loss = test_loss
+
+        if ReportTypes.RAY in reporttypes:
+            tune.report(
+                iterations=epoch,
+                train_loss=train_loss,
+                test_loss=test_loss,
+                **metric_dict,
+            )
+
+        if ReportTypes.MLFLOW in reporttypes:
+            mlflow.log_metric("Loss/train", train_loss, step=epoch)
+            mlflow.log_metric("Loss/test", test_loss, step=epoch)
+            for m in metric_dict:
+                mlflow.log_metric(f"metric/{m}", metric_dict[m], step=epoch)
+            lr = [group["lr"] for group in self.optimizer.param_groups][0]
+            mlflow.log_metric("learning_rate", lr, step=epoch)
+
+        if ReportTypes.TENSORBOARD in reporttypes:
+            self.writer.add_scalar("Loss/train", train_loss, epoch)
+            self.writer.add_scalar("Loss/test", test_loss, epoch)
+            for m in metric_dict:
+                self.writer.add_scalar(f"metric/{m}", metric_dict[m], epoch)
+            lr = [group["lr"] for group in self.optimizer.param_groups][0]
+            self.writer.add_scalar("learning_rate", lr, epoch)
+
+        metric_scores = [f"{v:.4f}" for v in metric_dict.values()]
+        logger.info(
+            f"Epoch {epoch} train {train_loss:.4f} test {test_loss:.4f} metric {metric_scores}"  # noqa E501
+        )
+
+
+class EarlyStopping:
+    def __init__(
+        self,
+        log_dir: Path,
+        patience: int = 7,
+        verbose: bool = False,
+        delta: float = 0.0,
+        save: bool = False,
+    ) -> None:
+        """
+        Args:
+            log_dir (Path): location to save checkpoint to.
+            patience (int): How long to wait after last time validation loss improved.
+                            Default: 7
+            verbose (bool): If True, prints a message for each validation loss improvement.
+                            Default: False
+            delta (float): Minimum change in the monitored quantity to qualify as an improvement.
+                            Default: 0.0
+        """
+        self.patience = patience
+        self.verbose = verbose
+        self.counter = 0
+        self.best_loss = None
+        self.early_stop = False
+        self.delta = delta
+        self.path = Path(log_dir) / "checkpoint.pt"
+        self.save = save
+
+    def __call__(self, val_loss: float, model: torch.nn.Module) -> None:
+        # first epoch best_loss is still None
+        if self.best_loss is None:
+            self.best_loss = val_loss  # type: ignore
+            if self.save:
+                self.save_checkpoint(val_loss, model)
+        elif val_loss >= self.best_loss + self.delta:  # type: ignore
+            # we minimize loss. If current loss did not improve
+            # the previous best (with a delta) it is considered not to improve.
+            self.counter += 1
+            logger.info(
+                f"best loss: {self.best_loss:.4f}, current loss {val_loss:.4f}. Counter {self.counter}/{self.patience}."
+            )
+            if self.counter >= self.patience:
+                self.early_stop = True
+        else:
+            # if not the first run, and val_loss is smaller, we improved.
+            self.best_loss = val_loss
+            if self.save:
+                self.save_checkpoint(val_loss, model)
+            self.counter = 0
+
+    def save_checkpoint(self, val_loss: float, model: torch.nn.Module) -> None:
+        """Saves model when validation loss decrease."""
+        if self.verbose:
+            logger.info(
+                f"Validation loss ({self.best_loss:.4f} --> {val_loss:.4f}). Saving {self.path} ..."
+            )
+        torch.save(model, self.path)
+        self.val_loss_min = val_loss
+
+    def get_best(self) -> torch.nn.Module:
+        return torch.load(self.path)

mltrainer/vae.py

@@ -0,0 +1,92 @@
+from typing import Dict
+
+import numpy as np
+import torch
+from torch import nn
+
+
+class Encoder(nn.Module):
+    """encoder"""
+
+    def __init__(self, config: Dict) -> None:
+        super().__init__()
+        self.flatten = nn.Flatten()
+        self.encode = nn.Sequential(
+            nn.Linear(config["insize"], config["h1"]),
+            nn.ReLU(),
+            nn.Linear(config["h1"], config["h2"]),
+            nn.ReLU(),
+            nn.Linear(config["h2"], config["latent"]),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.flatten(x)
+        latent = self.encode(x)
+        return latent
+
+
+class Decoder(nn.Module):
+    def __init__(self, config: Dict) -> None:
+        super().__init__()
+        self.decode = nn.Sequential(
+            nn.Linear(config["latent"], config["h2"]),
+            nn.ReLU(),
+            nn.Linear(config["h2"], config["h1"]),
+            nn.ReLU(),
+            nn.Linear(config["h1"], config["insize"]),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.decode(x)
+        x = x.reshape((-1, 28, 28, 1))
+        return x
+
+
+class RecostructionLoss:
+    def __call__(self, y, yhat):
+        sqe = (y - yhat) ** 2
+        summed = sqe.sum(dim=(1, 2, 3))
+        return summed.mean()
+
+
+class AutoEncoder(nn.Module):
+    def __init__(self, config: Dict) -> None:
+        super().__init__()
+        self.encoder = Encoder(config)
+        self.decoder = Decoder(config)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        latent = self.encoder(x)
+        x = self.decoder(latent)
+        return x
+
+
+def sample_range(encoder, stream, k: int = 10):
+    minmax_list = []
+    for _ in range(10):
+        X, _ = next(stream)
+        y = encoder(X).detach().numpy()
+        minmax_list.append(y.min())
+        minmax_list.append(y.max())
+    minmax = np.array(minmax_list)
+    return minmax.min(), minmax.max()
+
+
+def build_latent_grid(decoder, minimum: int, maximum: int, k: int = 20):
+    x = np.linspace(minimum, maximum, k)
+    y = np.linspace(minimum, maximum, k)
+    xx, yy = np.meshgrid(x, y)
+    grid = np.c_[xx.ravel(), yy.ravel()]
+
+    img = decoder(torch.tensor(grid, dtype=torch.float32))
+    return img.detach().numpy()
+
+
+def select_n_random(data, labels, n=300):
+    """
+    Selects n random datapoints and their corresponding labels from a dataset
+    """
+    assert len(data) == len(labels)
+
+    perm = torch.randperm(len(data))
+    return data[perm][:n], labels[perm][:n]

mltrainer-0.1.0.dist-info/METADATA

@@ -0,0 +1,35 @@
+Metadata-Version: 2.1
+Name: mltrainer
+Version: 0.1.0
+Summary: toolkit for training pytorch models
+Author-Email: R.Grouls <Raoul.Grouls@han.nl>
+License: MIT
+Requires-Python: >=3.10
+Requires-Dist: gin-config>=0.5.0
+Requires-Dist: numpy>=1.25.0
+Requires-Dist: torch>=2.0.1
+Requires-Dist: loguru>=0.7.0
+Requires-Dist: ray[tune]>=2.5.1
+Requires-Dist: tqdm>=4.65.0
+Requires-Dist: pydantic>=1.10.9
+Requires-Dist: torchvision>=0.15.2
+Requires-Dist: torchtext>=0.15.2
+Requires-Dist: torch-tb-profiler>=0.4.1
+Requires-Dist: Flake8-pyproject>=1.2.3; extra == "lint"
+Requires-Dist: pep8-naming>=0.13.3; extra == "lint"
+Requires-Dist: flake8-annotations>=3.0.1; extra == "lint"
+Requires-Dist: black>=23.3.0; extra == "lint"
+Requires-Dist: flake8>=6.0.0; extra == "lint"
+Requires-Dist: isort>=5.12.0; extra == "lint"
+Requires-Dist: mypy>=1.4.1; extra == "lint"
+Requires-Dist: mlflow>=2.4.1; extra == "tuning"
+Requires-Dist: bayesian-optimization>=1.4.3; extra == "tuning"
+Requires-Dist: hpbandster>=0.7.4; extra == "tuning"
+Requires-Dist: configspace>=0.7.1; extra == "tuning"
+Provides-Extra: lint
+Provides-Extra: tuning
+Description-Content-Type: text/markdown
+
+# ml-trainer
+
+toolkit for training pytorch models

mltrainer-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+mltrainer-0.1.0.dist-info/METADATA,sha256=hd0ou8TJux7Vc2hyXWTEb0mDH8Bt352SHHTS5dFX54Q,1198
+mltrainer-0.1.0.dist-info/WHEEL,sha256=g58cvAsF5_9d0VXJuk7F0rhl6nAjUc5P9vx880WkZtI,90
+mltrainer/__init__.py,sha256=2hFfroJy7TH3JYKcjaM5QiNacAiVp2hfCiWXK-QSC34,181
+mltrainer/imagemodels.py,sha256=cj_2nWUhadKRLNcpCXVEMQONMRXxhtaMrPTXxgGOu6Q,1653
+mltrainer/metrics.py,sha256=skurF5TbvZ8BWOI8EII5Ee0LTXOYk9Uh6u_UZWiOdh8,1653
+mltrainer/rnn_models.py,sha256=ydQzzDsVIGoVwqoGTqhsa5BognbZNvmenOcQY2Djyhs,4285
+mltrainer/settings.py,sha256=eaRuQWDFqs8Txe5RLhp4hj73ZTlUKmmOKzTs25utyeY,1543
+mltrainer/tokenizer.py,sha256=h9NaQj3E2utaNVqg07AxSkkAKwgrRr8kEDrGCdoOmb8,2388
+mltrainer/trainer.py,sha256=0VjFhZSFvvgLpWzRBe-JoMg_UE-T4yQNHqkp3ZgpPzs,8808
+mltrainer/vae.py,sha256=-mZ8zAFjIsjSi9a5rofBtM1FoSMyivy97ESy5Gxvb7s,2489
+mltrainer-0.1.0.dist-info/RECORD,,

mltrainer-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: pdm-backend (2.1.2)
+Root-Is-Purelib: true
+Tag: py3-none-any