diff --git a/.gitpod.yml b/.gitpod.yml index dd862f35..9e38f3c8 100644 --- a/.gitpod.yml +++ b/.gitpod.yml @@ -1,6 +1,2 @@ image: file: .gitpod.Dockerfile -ports: - - port: 8080 -tasks: - - command: jupyter lab --no-browser --port 8080 diff --git a/atomai/__version__.py b/atomai/__version__.py index c7056f36..2dfb789b 100644 --- a/atomai/__version__.py +++ b/atomai/__version__.py @@ -1 +1 @@ -version = '0.6.2' +version = '0.6.5' diff --git a/atomai/losses_metrics/__init__.py b/atomai/losses_metrics/__init__.py index b47c36ea..3a5c1d5a 100644 --- a/atomai/losses_metrics/__init__.py +++ b/atomai/losses_metrics/__init__.py @@ -1,4 +1,9 @@ -from .losses import dice_loss, focal_loss, select_loss, vae_loss, rvae_loss +from .losses import dice_loss, focal_loss, select_loss from .metrics import IoU +from .vi_losses import (joint_rvae_loss, joint_vae_loss, kld_discrete, + kld_normal, kld_rot, rvae_loss, vae_loss, + reconstruction_loss) -__all__ = ['focal_loss', 'dice_loss', 'select_seg_loss', 'IoU'] +__all__ = ['focal_loss', 'dice_loss', 'select_loss', "vae_loss", + "rvae_loss", "joint_vae_loss", "joint_rvae_loss", "IoU", + "kld_normal", "kld_discrete", "kld_rot", "reconstruction_loss"] diff --git a/atomai/losses_metrics/losses.py b/atomai/losses_metrics/losses.py index 46a5c8e2..83bd56e8 100644 --- a/atomai/losses_metrics/losses.py +++ b/atomai/losses_metrics/losses.py @@ -4,8 +4,6 @@ Custom Pytorch loss functions """ -from typing import Tuple -import numpy as np import torch import torch.nn.functional as F @@ -89,79 +87,9 @@ def forward(self, logits: torch.Tensor, labels: torch.Tensor) -> torch.Tensor: return (1 - dice_loss) -def vae_loss(reconstr_loss: str, - in_dim: Tuple[int], - x: torch.Tensor, - x_reconstr: torch.Tensor, - *args: torch.Tensor - ) -> torch.Tensor: - """ - Calculates ELBO - """ - batch_dim = x.size(0) - if len(args) == 2: - z_mean, z_logsd = args - else: - z_mean = z_logsd = torch.zeros((batch_dim, 1)) - z_sd = torch.exp(z_logsd) - if reconstr_loss == "mse": - reconstr_error = -0.5 * torch.sum( - (x_reconstr.reshape(batch_dim, -1) - x.reshape(batch_dim, -1))**2, 1).mean() - elif reconstr_loss == "ce": - px_size = np.product(in_dim) - rs = (np.product(in_dim[:2]),) - if len(in_dim) == 3: - rs = rs + (in_dim[-1],) - reconstr_error = -F.binary_cross_entropy_with_logits( - x_reconstr.reshape(-1, *rs), x.reshape(-1, *rs)) * px_size - else: - raise NotImplementedError("Reconstruction loss must be 'mse' or 'ce'") - kl_z = -z_logsd + 0.5 * z_sd**2 + 0.5 * z_mean**2 - 0.5 - kl_z = torch.sum(kl_z, 1).mean() - return reconstr_error - kl_z - - -def rvae_loss(reconstr_loss: str, - in_dim: Tuple[int], - x: torch.Tensor, - x_reconstr: torch.Tensor, - *args: torch.Tensor, - **kwargs: float) -> torch.Tensor: - """ - Calculates ELBO - """ - batch_dim = x.size(0) - if len(args) == 2: - z_mean, z_logsd = args - else: - z_mean = z_logsd = torch.zeros((batch_dim, 1)) - phi_prior = kwargs.get("phi_prior", 0.1) - z_sd = torch.exp(z_logsd) - phi_sd, phi_logsd = z_sd[:, 0], z_logsd[:, 0] - z_mean, z_sd, z_logsd = z_mean[:, 1:], z_sd[:, 1:], z_logsd[:, 1:] - batch_dim = x.size(0) - if reconstr_loss == "mse": - reconstr_error = -0.5 * torch.sum( - (x_reconstr.view(batch_dim, -1) - x.view(batch_dim, -1))**2, 1).mean() - elif reconstr_loss == "ce": - px_size = np.product(in_dim) - rs = (np.product(in_dim[:2]),) - if len(in_dim) == 3: - rs = rs + (in_dim[-1],) - reconstr_error = -F.binary_cross_entropy_with_logits( - x_reconstr.view(-1, *rs), x.view(-1, *rs)) * px_size - else: - raise NotImplementedError("Reconstruction loss must be 'mse' or 'ce'") - kl_rot = (-phi_logsd + np.log(phi_prior) + - phi_sd**2 / (2 * phi_prior**2) - 0.5) - kl_z = -z_logsd + 0.5 * z_sd**2 + 0.5 * z_mean**2 - 0.5 - kl_div = (kl_rot + torch.sum(kl_z, 1)).mean() - return reconstr_error - kl_div - - def select_loss(loss: str, nb_classes: int = None): """ - Selects loss for a semantic segmentation model training + Selects loss for DCNN model training """ if loss == 'ce' and nb_classes is None: raise ValueError("For cross-entropy loss function, you must" + diff --git a/atomai/losses_metrics/vi_losses.py b/atomai/losses_metrics/vi_losses.py new file mode 100644 index 00000000..f6510b17 --- /dev/null +++ b/atomai/losses_metrics/vi_losses.py @@ -0,0 +1,254 @@ +""" +vae_losses.py +========= + +Custom loss functions for Variational Autoencoders (VAEs) +""" +from typing import Tuple, List, Union, Optional +import numpy as np +import torch +import torch.nn.functional as F + + +def reconstruction_loss(loss_type: str, + in_dim: Tuple[int], + x: torch.Tensor, + x_reconstr: torch.Tensor, + logits: bool = True, + ) -> torch.Tensor: + """ + Computes reconstruction loss (mse or cross-entropy) + without mean reduction (used in VAE objectives) + """ + batch_dim = x.size(0) + if loss_type == "mse": + reconstr_loss = 0.5 * torch.sum( + (x_reconstr.reshape(batch_dim, -1) - x.reshape(batch_dim, -1))**2, 1) + elif loss_type == "ce": + rs = (np.product(in_dim[:2]),) + if len(in_dim) == 3: + rs = rs + (in_dim[-1],) + xe = (F.binary_cross_entropy_with_logits if + logits else F.binary_cross_entropy) + reconstr_loss = xe(x_reconstr.reshape(-1, *rs), x.reshape(-1, *rs), + reduction='none').sum(-1) + else: + raise NotImplementedError("Reconstruction loss must be 'mse' or 'ce'") + return reconstr_loss + + +def kld_normal(q_param: Tuple[torch.Tensor], + p_param: Optional[Tuple[torch.Tensor]] = None + ) -> torch.Tensor: + """ + Kullback–Leibler (KL) divergence between two normal distributions + """ + mu_1, log_sd_1 = q_param + sd_1 = torch.exp(log_sd_1) + if p_param is None: + # KL divergence b/w normal and standard normal distributions + kl = -log_sd_1 + 0.5 * sd_1**2 + 0.5 * mu_1**2 - 0.5 + else: + mu_2, log_sd_2 = p_param + sd_2 = torch.exp(log_sd_2) + # KL divergence b/w two normal distributions + kl = (log_sd_2 - log_sd_1 + + 0.5 * (sd_1**2 + (mu_1 - mu_2)**2) / sd_2**2 - 0.5) + return torch.sum(kl, -1) + + +def kld_discrete(alpha: torch.Tensor): + """ + Calculates the KL divergence between a Gumbel-Softmax distribution + and a uniform categorical distribution. + + Args: + alpha: + Parameters of the Gumbel-Softmax distribution. + """ + eps = 1e-12 + cat_dim = alpha.size(-1) + h1 = torch.log(alpha + eps) + h2 = np.log(1. / cat_dim + eps) + kld_loss = torch.mean(torch.sum(alpha * (h1 - h2), dim=1), dim=0) + return kld_loss.view(1) + + +def kld_rot(phi_prior: torch.Tensor, phi_logsd: torch.Tensor) -> torch.Tensor: + """ + Kullback–Leibler (KL) divergence for rotation latent variable + """ + phi_sd = torch.exp(phi_logsd) + kl_rot = (-phi_logsd + np.log(phi_prior) + + phi_sd**2 / (2 * phi_prior**2) - 0.5) + return kl_rot + + +def vae_loss(recon_loss: str, + in_dim: Tuple[int], + x: torch.Tensor, + x_reconstr: torch.Tensor, + *args: torch.Tensor, + ) -> torch.Tensor: + """ + Calculates ELBO + """ + if len(args) == 2: + q_param = args + else: + raise ValueError( + "Pass mean and SD values of encoded distribution as args") + likelihood = -reconstruction_loss(recon_loss, in_dim, x, x_reconstr).mean() + kl_z = kld_normal(q_param).mean() + return likelihood - kl_z + + +def rvae_loss(recon_loss: str, + in_dim: Tuple[int], + x: torch.Tensor, + x_reconstr: torch.Tensor, + *args: torch.Tensor, + **kwargs: float) -> torch.Tensor: + """ + Calculates ELBO + """ + if len(args) == 2: + z_mean, z_logsd = args + else: + raise ValueError( + "Pass mean and SD values of encoded distribution as args") + phi_prior = kwargs.get("phi_prior", 0.1) + b1, b2 = kwargs.get("b1", 1), kwargs.get("b2", 1) + phi_logsd = z_logsd[:, 0] + z_mean, z_logsd = z_mean[:, 1:], z_logsd[:, 1:] + likelihood = -reconstruction_loss(recon_loss, in_dim, x, x_reconstr).mean() + kl_rot = kld_rot(phi_prior, phi_logsd).mean() + kl_z = kld_normal([z_mean, z_logsd]).mean() + kl_div = (b1*kl_z + b2 * kl_rot) + return likelihood - kl_div + + +def joint_vae_loss(recon_loss: str, + in_dim: Tuple[int], + x: torch.Tensor, + x_reconstr: torch.Tensor, + *args: torch.Tensor, + **kwargs: Union[List, int], + ) -> torch.Tensor: + """ + Calculates joint ELBO for continuous and discrete variables + """ + if len(args) == 3: + z_mean, z_logsd, alphas = args + else: + raise ValueError( + "Pass continuous (mean, SD) and discrete (alphas) values" + + "of encoded distributions as args") + + cont_capacity = kwargs.get("cont_capacity", [0.0, 5.0, 25000, 30]) + disc_capacity = kwargs.get("disc_capacity", [0.0, 5.0, 25000, 30]) + num_iter = kwargs.get("num_iter", 0) + disc_dims = [a.size(1) for a in alphas] + + # Calculate reconstruction loss term + likelihood = -reconstruction_loss(recon_loss, in_dim, x, x_reconstr).mean() + + # Calculate KL term for continuous latent variables + kl_cont_loss = kld_normal([z_mean, z_logsd]).mean() + # Calculate KL term for discrete latent variables + kl_disc = [kld_discrete(alpha) for alpha in alphas] + kl_disc_loss = torch.sum(torch.cat(kl_disc)) + + # Apply information capacity terms to contninuous and discrete channels + cargs = [kl_cont_loss, kl_disc_loss, cont_capacity, + disc_capacity, disc_dims, num_iter] + cont_capacity_loss, disc_capacity_loss = infocapacity(*cargs) + + return likelihood - cont_capacity_loss - disc_capacity_loss + + +def joint_rvae_loss(recon_loss: str, + in_dim: Tuple[int], + x: torch.Tensor, + x_reconstr: torch.Tensor, + *args: torch.Tensor, + **kwargs: float) -> torch.Tensor: + """ + Calculates joint ELBO for continuous and discrete variables + """ + if len(args) == 3: + z_mean, z_logsd, alphas = args + else: + raise ValueError( + "Pass continuous (mean, SD) and discrete (alphas) values" + + "of encoded distributions as args") + + phi_prior = kwargs.get("phi_prior", 0.1) + klrot_cap = kwargs.get("klrot_cap", True) + cont_capacity = kwargs.get("cont_capacity", [0.0, 5.0, 25000, 30]) + disc_capacity = kwargs.get("disc_capacity", [0.0, 5.0, 25000, 30]) + num_iter = kwargs.get("num_iter", 0) + + # Calculate reconstruction loss term + likelihood = -reconstruction_loss(recon_loss, in_dim, x, x_reconstr).mean() + + # Calculate KL term for continuous latent variables + phi_logsd = z_logsd[:, 0] # rotation + z_mean, z_logsd = z_mean[:, 1:], z_logsd[:, 1:] # image content + kl_rot = kld_rot(phi_prior, phi_logsd).mean() + kl_z = kld_normal([z_mean, z_logsd]).mean() + if klrot_cap: + kl_cont_loss = kl_z + kl_rot + else: # no capacity limit on KL term associated with rotations + kl_cont_loss = kl_z + + # Calculate KL term for discrete latent variables + disc_dims = [a.size(1) for a in alphas] + kl_disc = [kld_discrete(alpha) for alpha in alphas] + kl_disc_loss = torch.sum(torch.cat(kl_disc)) + + # Apply information capacity terms to contninuous and discrete channels + cargs = [kl_cont_loss, kl_disc_loss, cont_capacity, + disc_capacity, disc_dims, num_iter] + cont_capacity_loss, disc_capacity_loss = infocapacity(*cargs) + if not klrot_cap: + cont_capacity_loss = cont_capacity_loss + kl_rot + + return likelihood - cont_capacity_loss - disc_capacity_loss + + +def infocapacity(kl_cont_loss: torch.Tensor, + kl_disc_loss: torch.Tensor, + cont_capacity: List[float], + disc_capacity: List[float], + disc_dims: List[int], + num_iter: int) -> torch.Tensor: + """ + Controls information capacity of the continuous and discrete loss + (based on https://arxiv.org/pdf/1804.00104.pdf & + https://github.com/Schlumberger/joint-vae/blob/master/jointvae/training.py) + """ + # Linearly increase capacity of continuous channels + cont_min, cont_max, cont_num_iters, cont_gamma = cont_capacity + # Increase continuous capacity without exceeding cont_max + cont_cap_current = (cont_max - cont_min) * num_iter + cont_cap_current = cont_cap_current / float(cont_num_iters) + cont_min + cont_cap_current = min(cont_cap_current, cont_max) + # Calculate continuous capacity loss + cont_capacity_loss = cont_gamma*torch.abs(cont_cap_current - kl_cont_loss) + + # Linearly increase capacity of discrete channels + disc_min, disc_max, disc_num_iters, disc_gamma = disc_capacity + # Increase discrete capacity without exceeding disc_max or theoretical + # maximum (i.e. sum of log of dimension of each discrete variable) + disc_cap_current = (disc_max - disc_min) * num_iter + disc_cap_current = disc_cap_current / float(disc_num_iters) + disc_min + disc_cap_current = min(disc_cap_current, disc_max) + # Require float conversion here to not end up with numpy float + disc_theory_max = sum([float(np.log(d)) for d in disc_dims]) + disc_cap_current = min(disc_cap_current, disc_theory_max) + # Calculate discrete capacity loss + disc_capacity_loss = disc_gamma*torch.abs(disc_cap_current - kl_disc_loss) + + return cont_capacity_loss, disc_capacity_loss + diff --git a/atomai/models/__init__.py b/atomai/models/__init__.py index 9ea599e5..b6f9ca33 100644 --- a/atomai/models/__init__.py +++ b/atomai/models/__init__.py @@ -1,7 +1,7 @@ from .segmentor import Segmentor from .imspec import ImSpec -from .vae import BaseVAE, VAE, rVAE +from .dgm import BaseVAE, VAE, rVAE, jVAE, jrVAE from .loaders import load_model, load_ensemble __all__ = ["Segmentor", "ImSpec", "BaseVAE", "VAE", "rVAE", - "load_model", "load_ensemble"] + "jVAE", "jrVAE", "load_model", "load_ensemble"] diff --git a/atomai/models/dgm/__init__.py b/atomai/models/dgm/__init__.py new file mode 100644 index 00000000..904e569d --- /dev/null +++ b/atomai/models/dgm/__init__.py @@ -0,0 +1,6 @@ +from .vae import BaseVAE, VAE +from .rvae import rVAE +from .jvae import jVAE +from .jrvae import jrVAE + +__all__ = ["BaseVAE", "VAE", "rVAE", "jVAE", "jrVAE"] diff --git a/atomai/models/dgm/jrvae.py b/atomai/models/dgm/jrvae.py new file mode 100644 index 00000000..eb8c9108 --- /dev/null +++ b/atomai/models/dgm/jrvae.py @@ -0,0 +1,231 @@ +""" +jrvae.py +======= + +Module for analysis of system "building blocks" with rotationally-invariant +variational autoencoders for joint continuous and discrete representations + +Created by Maxim Ziatdinov (email: maxim.ziatdinov@ai4microscopy.com) +""" + +from typing import Optional, Union, List + +from copy import deepcopy as dc +import numpy as np +import torch + +from ...losses_metrics import joint_rvae_loss + +from ...utils import set_train_rng, to_onehot, transform_coordinates +from .vae import BaseVAE + + +class jrVAE(BaseVAE): + """ + Rotationally-invariant VAE for joint continuous and + discrete latent representations. + + Args: + in_dim: + Input dimensions for image data passed as (heigth, width) + for grayscale data or (height, width, channels) + for multichannel data + latent_dim: + Number of latent dimensions associated with image content + discrete_dim: + List specifying dimensionalities of discrete (Gumbel-Softmax) + latent variables associated with image content + nb_classes: + Number of classes for class-conditional VAE + translation: + account for xy shifts of image content (Default: True) + seed: + seed for torch and numpy (pseudo-)random numbers generators + **conv_encoder (bool): + use convolutional layers in encoder + **numlayers_encoder (int): + number of layers in encoder (Default: 2) + **numlayers_decoder (int): + number of layers in decoder (Default: 2) + **numhidden_encoder (int): + number of hidden units OR conv filters in encoder (Default: 128) + **numhidden_decoder (int): + number of hidden units in decoder (Default: 128) + **skip (bool): + uses generative skip model with residual paths between + latents and decoder layers (Default: False) + + Example: + + >>> input_dim = (28, 28) # intput dimensions + >>> # Intitialize model + >>> jrvae = aoi.models.jVAE(input_dim, latent_dim=2, discrete_dim=[10], + >>> numlayers_encoder=3, numhidden_encoder=512, + >>> numlayers_decoder=3, numhidden_decoder=512) + >>> # Train + >>> jrvae.fit(imstack_train, training_cycles=100, + batch_size=100, rotation_prior=np.pi/4) + >>> jrvae.manifold2d(origin="upper", cmap="gnuplot2") + + """ + def __init__(self, + in_dim: int = None, + latent_dim: int = 2, + discrete_dim: List[int] = [2], + nb_classes: int = 0, + translation: bool = True, + seed: int = 0, + **kwargs: Union[int, bool, str] + ) -> None: + """ + Initializes joint rVAE model (jrVAE) + """ + coord = 3 if translation else 1 # xy translations and/or rotation + args = (in_dim, latent_dim, nb_classes, coord, discrete_dim) + super(jrVAE, self).__init__(*args, **kwargs) + set_train_rng(seed) + self.translation = translation + self.dx_prior = None + self.phi_prior = None + self.anneal_dict = None + self.kdict_ = dc(kwargs) + self.kdict_["num_iter"] = 0 + + def elbo_fn(self, + x: torch.Tensor, + x_reconstr: torch.Tensor, + *args: torch.Tensor, + **kwargs: Union[List, int] + ) -> torch.Tensor: + """ + Computes ELBO + """ + return joint_rvae_loss(self.loss, self.in_dim, x, x_reconstr, *args, **kwargs) + + def forward_compute_elbo(self, + x: torch.Tensor, + y: Optional[torch.Tensor] = None, + mode: str = "train" + ) -> torch.Tensor: + """ + Joint rVAE's forward pass with training/test loss computation + """ + tau = self.kdict_.get("temperature", .67) + x_coord_ = self.x_coord.expand(x.size(0), *self.x_coord.size()) + x = x.to(self.device) + if mode == "eval": + with torch.no_grad(): + latent_ = self.encoder_net(x) + else: + latent_ = self.encoder_net(x) + self.kdict_["num_iter"] += 1 + + z_mean, z_logsd = latent_[:2] + z_sd = torch.exp(z_logsd) + z_cont = self.reparameterize(z_mean, z_sd) + phi = z_cont[:, 0] # angle + if self.translation: + dx = z_cont[:, 1:3] # translation + dx = (dx * self.dx_prior).unsqueeze(1) + z_cont = z_cont[:, 3:] # image content + else: + dx = 0 # no translation + z_cont = z_cont[:, 1:] # image content + x_coord_ = transform_coordinates(x_coord_, phi, dx) + + alphas = latent_[2:] + z_disc = [self.reparameterize_discrete(a, tau) for a in alphas] + z_disc = torch.cat(z_disc, 1) + + z = torch.cat((z_cont, z_disc), dim=1) + + if y is not None: + targets = to_onehot(y, self.nb_classes) + z = torch.cat((z, targets), -1) + + if mode == "eval": + with torch.no_grad(): + x_reconstr = self.decoder_net(x_coord_, z) + else: + x_reconstr = self.decoder_net(x_coord_, z) + + return self.elbo_fn(x, x_reconstr, z_mean, z_logsd, alphas, **self.kdict_) + + def fit(self, + X_train: Union[np.ndarray, torch.Tensor], + y_train: Optional[Union[np.ndarray, torch.Tensor]] = None, + X_test: Optional[Union[np.ndarray, torch.Tensor]] = None, + y_test: Optional[Union[np.ndarray, torch.Tensor]] = None, + loss: str = "mse", + **kwargs) -> None: + """ + Trains joint rVAE model + + Args: + X_train: + 3D or 4D stack of training images with dimensions + (n_images, height, width) for grayscale data or + or (n_images, height, width, channels) for multi-channel data + X_test: + 3D or 4D stack of test images with the same dimensions + as for the X_train (Default: None) + y_train: + Vector with labels of dimension (n_images,), where n_images + is a number of training images + y_train: + Vector with labels of dimension (n_images,), where n_images + is a number of test images + loss: + reconstruction loss function, "ce" or "mse" (Default: "mse") + **translation_prior (float): + translation prior + **rotation_prior (float): + rotational prior + **temperature (float): + Relaxation parameter for Gumbel-Softmax distribution + **cont_capacity (list): + List containing (min_capacity, max_capacity, num_iters, gamma_z) + parameters to control the capacity of the continuous latent + channels. Default values: [0.0, 5.0, 25000, 30]. + Based on https://arxiv.org/abs/1804.00104 + **disc_capacity (list): + List containing (min_capacity, max_capacity, num_iters, gamma_c) + parameters to control the capacity of the discrete latent channels. + Default values: [0.0, 5.0, 25000, 30]. + Based on https://arxiv.org/abs/1804.00104 + **klrot_cap (bool): + Do not control capacity of KL term associated + with rotations of coordinate grid + **filename (str): + file path for saving model aftereach training cycle ("epoch") + """ + self._check_inputs(X_train, y_train, X_test, y_test) + self.dx_prior = kwargs.get("translation_prior", 0.1) + self.kdict_["phi_prior"] = kwargs.get("rotation_prior", 0.1) + self.anneal_dict = kwargs.get("anneal_dict") + for k, v in kwargs.items(): + if k in ["cont_capacity", "disc_capacity", + "temperature", "klrot_cap"]: + self.kdict_[k] = v + self.compile_trainer( + (X_train, y_train), (X_test, y_test), **kwargs) + self.loss = loss # this part needs to be handled better + if self.loss == "ce": + self.sigmoid_out = True # Use sigmoid layer for "prediction" stage + self.metadict["sigmoid_out"] = True + self.recording = kwargs.get("recording", False) + + for e in range(self.training_cycles): + self.current_epoch = e + elbo_epoch = self.train_epoch() + self.loss_history["train_loss"].append(elbo_epoch) + if self.test_iterator is not None: + elbo_epoch_test = self.evaluate_model() + self.loss_history["test_loss"].append(elbo_epoch_test) + self.print_statistics(e) + self.update_metadict() + self.save_model(self.filename) + + def update_metadict(self): + self.metadict["num_epochs"] = self.current_epoch + self.metadict["num_iter"] = self.kdict_["num_iter"] diff --git a/atomai/models/dgm/jvae.py b/atomai/models/dgm/jvae.py new file mode 100644 index 00000000..ce640c95 --- /dev/null +++ b/atomai/models/dgm/jvae.py @@ -0,0 +1,199 @@ +""" +jvae.py +======= + +Module for analysis of system "building blocks" with variational autoencoders +for joint continuous and discrete representations + +Created by Maxim Ziatdinov (email: maxim.ziatdinov@ai4microscopy.com) +""" + +from typing import Optional, Union, List + +from copy import deepcopy as dc +import numpy as np +import torch + +from ...losses_metrics import joint_vae_loss + +from ...utils import set_train_rng, to_onehot +from .vae import BaseVAE + + +class jVAE(BaseVAE): + """ + VAE for joint (continuous + discrete) latent representations + + Args: + in_dim: + Input dimensions for image data passed as (heigth, width) + for grayscale data or (height, width, channels) + for multichannel data + latent_dim: + Number of latent dimensions associated with image content + discrete_dim: + List specifying dimensionalities of discrete (Gumbel-Softmax) + latent variables associated with image content + nb_classes: + Number of classes for class-conditional VAE + seed: + seed for torch and numpy (pseudo-)random numbers generators + **conv_encoder (bool): + use convolutional layers in encoder + **conv_decoder (bool): + use convolutional layers in decoder + **numlayers_encoder (int): + number of layers in encoder (Default: 2) + **numlayers_decoder (int): + number of layers in decoder (Default: 2) + **numhidden_encoder (int): + number of hidden units OR conv filters in encoder (Default: 128) + **numhidden_decoder (int): + number of hidden units in decoder (Default: 128) + **skip (bool): + uses generative skip model with residual paths between + latents and decoder layers (Default: False) + + Example: + + >>> input_dim = (28, 28) # intput dimensions + >>> # Intitialize model + >>> jvae = aoi.models.jVAE(input_dim, latent_dim=2, discrete_dim=[10], + >>> numlayers_encoder=3, numhidden_encoder=512, + >>> numlayers_decoder=3, numhidden_decoder=512) + >>> # Train + >>> jvae.fit(imstack_train, training_cycles=100, batch_size=100) + >>> # View a traversal of the learned manifold + >>> jvae.manifold_traversal(cont_idx=1, origin="upper", cmap="gnuplot2") + """ + def __init__(self, + in_dim: int = None, + latent_dim: int = 2, + discrete_dim: List[int] = [2], + nb_classes: int = 0, + seed: int = 0, + **kwargs: Union[int, bool, str] + ) -> None: + """ + Initializes jVAE model + """ + args = (in_dim, latent_dim, nb_classes, 0, discrete_dim) + super(jVAE, self).__init__(*args, **kwargs) + set_train_rng(seed) + self.kdict_ = dc(kwargs) + self.kdict_["num_iter"] = 0 + + def elbo_fn(self, + x: torch.Tensor, + x_reconstr: torch.Tensor, + *args: torch.Tensor, + **kwargs: Union[List, int] + ) -> torch.Tensor: + """ + Computes ELBO + """ + return joint_vae_loss(self.loss, self.in_dim, x, x_reconstr, *args, **kwargs) + + def forward_compute_elbo(self, + x: torch.Tensor, + y: Optional[torch.Tensor] = None, + mode: str = "train" + ) -> torch.Tensor: + """ + Joint VAE's forward pass with training/test loss computation + """ + tau = self.kdict_.get("temperature", .67) + x = x.to(self.device) + if mode == "eval": + with torch.no_grad(): + latent_ = self.encoder_net(x) + else: + latent_ = self.encoder_net(x) + self.kdict_["num_iter"] += 1 + z_mean, z_logsd = latent_[:2] + z_sd = torch.exp(z_logsd) + z_cont = self.reparameterize(z_mean, z_sd) + + alphas = latent_[2:] + z_disc = [self.reparameterize_discrete(a, tau) for a in alphas] + z_disc = torch.cat(z_disc, 1) + + z = torch.cat((z_cont, z_disc), dim=1) + + if y is not None: + targets = to_onehot(y, self.nb_classes) + z = torch.cat((z, targets), -1) + + if mode == "eval": + with torch.no_grad(): + x_reconstr = self.decoder_net(z) + else: + x_reconstr = self.decoder_net(z) + + return self.elbo_fn(x, x_reconstr, z_mean, z_logsd, alphas, **self.kdict_) + + def fit(self, + X_train: Union[np.ndarray, torch.Tensor], + y_train: Optional[Union[np.ndarray, torch.Tensor]] = None, + X_test: Optional[Union[np.ndarray, torch.Tensor]] = None, + y_test: Optional[Union[np.ndarray, torch.Tensor]] = None, + loss: str = "mse", + **kwargs) -> None: + """ + Trains joint VAE model + + Args: + X_train: + For images, 3D or 4D stack of training images with dimensions + (n_images, height, width) for grayscale data or + or (n_images, height, width, channels) for multi-channel data. + For spectra, 2D stack of spectra with dimensions (length,) + X_test: + 3D or 4D stack of test images or 2D stack of spectra with + the same dimensions as for the X_train (Default: None) + y_train: + Vector with labels of dimension (n_images,), where n_images + is a number of training images/spectra + y_train: + Vector with labels of dimension (n_images,), where n_images + is a number of test images/spectra + loss: + reconstruction loss function, "ce" or "mse" (Default: "mse") + **cont_capacity (list): + List containing (min_capacity, max_capacity, num_iters, gamma_z) + parameters to control the capacity of the continuous latent + channels. Default values: [0.0, 5.0, 25000, 30]. + Based on https://arxiv.org/abs/1804.00104 + **disc_capacity (list): + List containing (min_capacity, max_capacity, num_iters, gamma_c) + parameters to control the capacity of the discrete latent channels. + Default values: [0.0, 5.0, 25000, 30]. + Based on https://arxiv.org/abs/1804.00104 + **filename (str): + file path for saving model aftereach training cycle ("epoch") + """ + self._check_inputs(X_train, y_train, X_test, y_test) + for k, v in kwargs.items(): + if k in ["cont_capacity", "disc_capacity", "temperature"]: + self.kdict_[k] = v + self.compile_trainer( + (X_train, y_train), (X_test, y_test), **kwargs) + self.loss = loss # this part needs to be handled better + if self.loss == "ce": + self.sigmoid_out = True # Use sigmoid layer for "prediction" stage + self.metadict["sigmoid_out"] = True + for e in range(self.training_cycles): + self.current_epoch = e + elbo_epoch = self.train_epoch() + self.loss_history["train_loss"].append(elbo_epoch) + if self.test_iterator is not None: + elbo_epoch_test = self.evaluate_model() + self.loss_history["test_loss"].append(elbo_epoch_test) + self.print_statistics(e) + self.update_metadict() + self.save_model(self.filename) + return + + def update_metadict(self): + self.metadict["num_epochs"] = self.current_epoch + self.metadict["num_iter"] = self.kdict_["num_iter"] diff --git a/atomai/models/dgm/rvae.py b/atomai/models/dgm/rvae.py new file mode 100644 index 00000000..6f3f7a40 --- /dev/null +++ b/atomai/models/dgm/rvae.py @@ -0,0 +1,215 @@ +""" +rvae.py +======= + +Module for analysis of system "building blocks" with +rotationally-invariant variational autoencoders + +Created by Maxim Ziatdinov (email: maxim.ziatdinov@ai4microscopy.com) +""" + + +from typing import Optional, Union + +import numpy as np +import torch + +from ...losses_metrics import rvae_loss + +from ...utils import set_train_rng, to_onehot, transform_coordinates +from .vae import BaseVAE + + +class rVAE(BaseVAE): + """ + Implements rotationally and translationally invariant + Variational Autoencoder (VAE) based on the idea of "spatial decoder" + by Bepler et al. in arXiv:1909.11663. In addition, this class allows + implementating the class-conditioned VAE and skip-VAE (arXiv:1807.04863) + with rotational and translational variance. + + Args: + in_dim: + Input dimensions for image data passed as (heigth, width) + for grayscale data or (height, width, channels) + for multichannel data + latent_dim: + Number of VAE latent dimensions associated with image content + nb_classes: + Number of classes for class-conditional rVAE + translation: + account for xy shifts of image content (Default: True) + seed: + seed for torch and numpy (pseudo-)random numbers generators + **conv_encoder (bool): + use convolutional layers in encoder + **numlayers_encoder (int): + number of layers in encoder (Default: 2) + **numlayers_decoder (int): + number of layers in decoder (Default: 2) + **numhidden_encoder (int): + number of hidden units OR conv filters in encoder (Default: 128) + **numhidden_decoder (int): + number of hidden units in decoder (Default: 128) + **skip (bool): + uses generative skip model with residual paths between + latents and decoder layers (Default: False) + + Example: + + >>> input_dim = (28, 28) # intput dimensions + >>> # Intitialize model + >>> rvae = aoi.models.rVAE(input_dim) + >>> # Train + >>> rvae.fit(imstack_train, training_cycles=100, + batch_size=100, rotation_prior=np.pi/2) + >>> rvae.manifold2d(origin="upper", cmap="gnuplot2") + + One can also pass labels to train a class-conditioned rVAE + + >>> # Intitialize model + >>> rvae = aoi.models.rVAE(input_dim, nb_classes=10) + >>> # Train + >>> rvae.fit(imstack_train, labels_train, training_cycles=100, + >>> batch_size=100, rotation_prior=np.pi/2) + >>> # Visualize learned manifold for class 1 + >>> rvae.manifold2d(label=1, origin="upper", cmap="gnuplot2") + """ + + def __init__(self, + in_dim: int = None, + latent_dim: int = 2, + nb_classes: int = 0, + translation: bool = True, + seed: int = 0, + **kwargs: Union[int, bool, str] + ) -> None: + """ + Initializes rVAE model + """ + coord = 3 if translation else 1 # xy translations and/or rotation + args = (in_dim, latent_dim, nb_classes, coord) + super(rVAE, self).__init__(*args, **kwargs) + set_train_rng(seed) + self.translation = translation + self.dx_prior = None + self.phi_prior = None + self.anneal_dict = None + + def elbo_fn(self, + x: torch.Tensor, + x_reconstr: torch.Tensor, + *args: torch.Tensor, + **kwargs: float + ) -> torch.Tensor: + """ + Computes ELBO + """ + return rvae_loss(self.loss, self.in_dim, x, x_reconstr, *args, **kwargs) + + def forward_compute_elbo(self, + x: torch.Tensor, + y: Optional[torch.Tensor] = None, + mode: str = "train" + ) -> torch.Tensor: + """ + rVAE's forward pass with training/test loss computation + """ + x_coord_ = self.x_coord.expand(x.size(0), *self.x_coord.size()) + if mode == "eval": + with torch.no_grad(): + z_mean, z_logsd = self.encoder_net(x) + else: + z_mean, z_logsd = self.encoder_net(x) + z_sd = torch.exp(z_logsd) + z = self.reparameterize(z_mean, z_sd) + phi = z[:, 0] # angle + if self.translation: + dx = z[:, 1:3] # translation + dx = (dx * self.dx_prior).unsqueeze(1) + z = z[:, 3:] # image content + else: + dx = 0 # no translation + z = z[:, 1:] # image content + + if y is not None: + targets = to_onehot(y, self.nb_classes) + z = torch.cat((z, targets), -1) + + x_coord_ = transform_coordinates(x_coord_, phi, dx) + if mode == "eval": + with torch.no_grad(): + x_reconstr = self.decoder_net(x_coord_, z) + else: + x_reconstr = self.decoder_net(x_coord_, z) + # KL annealing terms + b1 = b2 = 1 + if isinstance(self.anneal_dict, dict): + e_ = self.current_epoch + b1 = self.anneal_dict["kl_im"] + b2 = self.anneal_dict["kl_rot"] + b1 = b1[-1] if len(b1) < e_ + 1 else b1[e_] + b2 = b2[-1] if len(b2) < e_ + 1 else b2[e_] + return self.elbo_fn(x, x_reconstr, z_mean, z_logsd, + phi_prior=self.phi_prior, b1=b1, b2=b2) + + def fit(self, + X_train: Union[np.ndarray, torch.Tensor], + y_train: Optional[Union[np.ndarray, torch.Tensor]] = None, + X_test: Optional[Union[np.ndarray, torch.Tensor]] = None, + y_test: Optional[Union[np.ndarray, torch.Tensor]] = None, + loss: str = "mse", + **kwargs) -> None: + """ + Trains rVAE model + + Args: + X_train: + 3D or 4D stack of training images with dimensions + (n_images, height, width) for grayscale data or + or (n_images, height, width, channels) for multi-channel data + X_test: + 3D or 4D stack of test images with the same dimensions + as for the X_train (Default: None) + y_train: + Vector with labels of dimension (n_images,), where n_images + is a number of training images + y_train: + Vector with labels of dimension (n_images,), where n_images + is a number of test images + loss: + reconstruction loss function, "ce" or "mse" (Default: "mse") + **translation_prior (float): + translation prior + **rotation_prior (float): + rotational prior + **filename (str): + file path for saving model aftereach training cycle ("epoch") + **recording (bool): + saves a learned 2d manifold at each training step + """ + self._check_inputs(X_train, y_train, X_test, y_test) + self.dx_prior = kwargs.get("translation_prior", 0.1) + self.phi_prior = kwargs.get("rotation_prior", 0.1) + self.anneal_dict = kwargs.get("anneal_dict") + self.compile_trainer( + (X_train, y_train), (X_test, y_test), **kwargs) + self.loss = loss # this part needs to be handled better + if self.loss == "ce": + self.sigmoid_out = True # Use sigmoid layer for "prediction" stage + self.metadict["sigmoid_out"] = True + self.recording = kwargs.get("recording", False) + + for e in range(self.training_cycles): + self.current_epoch = e + elbo_epoch = self.train_epoch() + self.loss_history["train_loss"].append(elbo_epoch) + if self.test_iterator is not None: + elbo_epoch_test = self.evaluate_model() + self.loss_history["test_loss"].append(elbo_epoch_test) + self.print_statistics(e) + if self.recording and self.z_dim in [3, 5]: + self.manifold2d(savefig=True, filename=str(e)) + self.save_model(self.filename) + if self.recording and self.z_dim in [3, 5]: + self.visualize_manifold_learning("./vae_learning") diff --git a/atomai/models/vae.py b/atomai/models/dgm/vae.py similarity index 63% rename from atomai/models/vae.py rename to atomai/models/dgm/vae.py index 55964a91..225bd236 100644 --- a/atomai/models/vae.py +++ b/atomai/models/dgm/vae.py @@ -2,7 +2,7 @@ vae.py ======= -Module for analysis of system "building blocks"" with variational autoencoders +Module for analysis of system "building blocks" with variational autoencoders Created by Maxim Ziatdinov (email: maxim.ziatdinov@ai4microscopy.com) """ @@ -14,19 +14,20 @@ import numpy as np import torch from scipy.stats import norm +from torchvision.utils import make_grid -from ..losses_metrics import rvae_loss, vae_loss -from ..nets import (convDecoderNet, convEncoderNet, fcDecoderNet, fcEncoderNet, - rDecoderNet, init_VAE_nets) -from ..trainers import viBaseTrainer -from ..utils import (crop_borders, extract_subimages, get_coord_grid, - imcoordgrid, set_train_rng, subimg_trajectories, - transform_coordinates) +from ...losses_metrics import vae_loss + +from ...nets import init_VAE_nets +from ...trainers import viBaseTrainer +from ...utils import (crop_borders, extract_subimages, get_coord_grid, + imcoordgrid, set_train_rng, subimg_trajectories, + to_onehot) class BaseVAE(viBaseTrainer): """ - General class for encoder-decoder type of deep latent variable models + General class for VAE models Args: in_dim: @@ -54,7 +55,8 @@ def __init__(self, in_dim: Tuple[int], latent_dim: int, nb_classes: int = 0, - coord: bool = True, + coord: int = 0, + discrete_dim: Optional[List] = None, seed: int = 0, **kwargs: Union[int, bool]) -> None: super(BaseVAE, self).__init__() @@ -79,61 +81,30 @@ def __init__(self, self.in_dim = in_dim self.z_dim = latent_dim + if isinstance(discrete_dim, list): + self.z_dim = self.z_dim + sum(discrete_dim) + self.discrete_dim = discrete_dim + if coord: if len(in_dim) not in (2, 3): raise NotImplementedError( "VAE with rotation and translational invariance are " + "available only for 2D image data") - self.z_dim = latent_dim + coord + self.z_dim = self.z_dim + coord + self.x_coord = imcoordgrid(in_dim).to(self.device) self.nb_classes = nb_classes (encoder_net, decoder_net, self.metadict) = init_VAE_nets( - in_dim, latent_dim, coord, nb_classes, **kwargs) + in_dim, latent_dim, coord, discrete_dim, + nb_classes, **kwargs) self.set_model(encoder_net, decoder_net) - + self.sigmoid_out = self.metadict["sigmoid_out"] self.coord = coord - def load_weights(self, filepath: str) -> None: - """ - Loads saved weights - """ - weights = torch.load(filepath, map_location=self.device) - encoder_weights = weights["encoder"] - decoder_weights = weights["decoder"] - self.encoder_net.load_state_dict(encoder_weights) - self.encoder_net.eval() - self.decoder_net.load_state_dict(decoder_weights) - self.decoder_net.eval() - - def save_weights(self, *args: List[str]) -> None: - """ - Saves trained weights - """ - try: - savepath = args[0] - except IndexError: - savepath = "./VAE" - torch.save({"encoder": self.encoder_net.state_dict(), - "decoder": self.decoder_net.state_dict()}, - savepath + ".tar") - - def save_model(self, *args: List[str]) -> None: - """ - Saves trained weights and the key model parameters - """ - try: - savepath = args[0] - except IndexError: - savepath = "./VAE_metadict" - self.metadict["encoder"] = self.encoder_net.state_dict() - self.metadict["decoder"] = self.decoder_net.state_dict() - self.metadict["optimizer"] = self.optim - torch.save(self.metadict, savepath + ".tar") - - def encode(self, - x_test: Union[np.ndarray, torch.Tensor], - **kwargs: int) -> Tuple[np.ndarray]: + def encode_(self, + x_new: Union[np.ndarray, torch.Tensor], + **kwargs: int) -> Tuple[np.ndarray]: """ Encodes input image data using a trained VAE's encoder @@ -144,38 +115,60 @@ def encode(self, number of batches (Default: 10) Returns: - Mean and SD of the encoded distribution + Concatenated array of encoded vectors """ def inference() -> np.ndarray: with torch.no_grad(): - z_mean, z_sd = self.encoder_net(x_i) - return z_mean.cpu().numpy(), torch.exp(z_sd.cpu()).numpy() - - if isinstance(x_test, np.ndarray): - x_test = torch.from_numpy(x_test).float() - if (x_test.ndim == len(self.in_dim) == 2 or - x_test.ndim == len(self.in_dim) == 3): - x_test = x_test.unsqueeze(0) - if torch.cuda.is_available(): - x_test = x_test.cuda() - self.encoder_net.cuda() - num_batches = kwargs.get("num_batches", 10) - batch_size = len(x_test) // num_batches - z_mean_all = np.zeros((x_test.shape[0], self.z_dim)) - z_sd_all = np.zeros((x_test.shape[0], self.z_dim)) + encoded = self.encoder_net(x_i) + encoded = torch.cat(encoded, -1).cpu().numpy() + return encoded + if isinstance(x_new, np.ndarray): + x_new = torch.from_numpy(x_new).float() + if (x_new.ndim == len(self.in_dim) == 2 or + x_new.ndim == len(self.in_dim) == 3): + x_new = x_new.unsqueeze(0) + x_new = x_new.to(self.device) + num_batches = kwargs.get("num_batches", 10) + batch_size = len(x_new) // num_batches + z_encoded = [] for i in range(num_batches): - x_i = x_test[i*batch_size:(i+1)*batch_size] - z_mean_i, z_sd_i = inference() - z_mean_all[i*batch_size:(i+1)*batch_size] = z_mean_i - z_sd_all[i*batch_size:(i+1)*batch_size] = z_sd_i - x_i = x_test[(i+1)*batch_size:] + x_i = x_new[i*batch_size:(i+1)*batch_size] + z_encoded_i = inference() + z_encoded.append(z_encoded_i) + x_i = x_new[(i+1)*batch_size:] if len(x_i) > 0: - z_mean_i, z_sd_i = inference() - z_mean_all[(i+1)*batch_size:] = z_mean_i - z_sd_all[(i+1)*batch_size:] = z_sd_i + z_encoded_i = inference() + z_encoded.append(z_encoded_i) + return np.concatenate(z_encoded) - return z_mean_all, z_sd_all + def encode(self, + x_new: Union[np.ndarray, torch.Tensor], + **kwargs: int) -> Tuple[np.ndarray]: + """ + Encodes input image data using a trained VAE's encoder + + Args: + x_test: + image array to encode + **num_batches: + number of batches (Default: 10) + + Returns: + Mean and SD of the encoded continuous distribution, + and alphas ("class probabilities") for the encoded + discrete distribution(s) (if any) + """ + z = self.encode_(x_new, **kwargs) + if not self.discrete_dim: + z_mean = z[:, :self.z_dim] + z_logsd = z[:, self.z_dim:] + return z_mean, z_logsd + cont_dim = self.z_dim - sum(self.discrete_dim) + z_mean = z[:, :cont_dim] + z_logsd = z[:, cont_dim:cont_dim+cont_dim] + alphas = z[:, cont_dim+cont_dim:] + return z_mean, z_logsd, alphas def decode(self, z_sample: Union[np.ndarray, torch.Tensor], y: Optional[Union[int, np.ndarray, torch.Tensor]] = None @@ -197,13 +190,7 @@ def decode(self, z_sample: Union[np.ndarray, torch.Tensor], if len(z_sample.size()) == 1: z_sample = z_sample[None, ...] if self.coord: - xx = torch.linspace(-1, 1, self.in_dim[0]) - yy = torch.linspace(1, -1, self.in_dim[1]) - x0, x1 = torch.meshgrid(xx, yy) - x_coord = torch.stack([x0.T.flatten(), x1.T.flatten()], axis=1) - x_coord = x_coord.expand(z_sample.size(0), *x_coord.size()) - if torch.cuda.is_available(): - x_coord = x_coord.cuda() + x_coord = self.x_coord.expand(z_sample.size(0), *self.x_coord.size()) z_sample = z_sample.cuda() if torch.cuda.is_available() else z_sample if y is not None: if isinstance(y, int): @@ -223,12 +210,14 @@ def decode(self, z_sample: Union[np.ndarray, torch.Tensor], x_decoded = self.decoder_net(x_coord, z_sample) else: x_decoded = self.decoder_net(z_sample) + if self.sigmoid_out: + x_decoded = torch.sigmoid(x_decoded) imdec = x_decoded.cpu().numpy() return imdec - def forward_(self, - x_new: Union[np.ndarray, torch.Tensor], - **kwargs: int) -> np.ndarray: + def reconstruct(self, + x_new: Union[np.ndarray, torch.Tensor], + **kwargs: int) -> np.ndarray: """ Forward prediction with uncertainty quantification by sampling from the encoded mean and std. Works only for regular VAE (and not for rVAE) @@ -236,6 +225,8 @@ def forward_(self, Args: x_new: image array to encode + **label: + class to be reconstructed (for cVAE, crVAE, jVAE, and jrVAE) **num_samples: number of samples to generate from normal distribution @@ -243,20 +234,34 @@ def forward_(self, Ensemble of "decoded" images """ num_samples = kwargs.get("num_samples", 32) + label = kwargs.get("label") if isinstance(x_new, np.ndarray): x_new = torch.from_numpy(x_new).float() if torch.cuda.is_available(): x_new = x_new.cuda() self.encoder_net.cuda() with torch.no_grad(): - z_mean, z_logsd = self.encoder_net(x_new) + encoded = self.encoder_net(x_new) + if len(encoded) == 2: + z_mean, z_logsd = encoded + else: + z_mean, z_logsd, alphas = encoded + z_mean = z_mean[:, self.coord:] + z_logsd = z_logsd[:, self.coord:] + if label is not None: + n = self.nb_classes if self.discrete_dim is None else self.discrete_dim # probably makes sense to use nb_classes for j(r)VAE's discrete_dim + alphas = to_onehot( + torch.tensor(label).unsqueeze(0).to(self.device), + torch.tensor(n).to(self.device)) z_sd = torch.exp(z_logsd) ndist = torch.distributions.Normal(z_mean, z_sd) decoded_all = [] for i in range(num_samples): z_sample = ndist.rsample() z_sample = z_sample.view(1, -1) - decoded_all.append(self.decode_(z_sample)) + if len(encoded) > 2 or label is not None: + z_sample = torch.cat([z_sample, alphas], dim=1) + decoded_all.append(self.decode(z_sample)) decoded_all = np.concatenate(decoded_all, axis=0) return decoded_all @@ -374,7 +379,7 @@ def encode_trajectories(self, trajectories_enc_all.append(traj_enc) return trajectories_enc_all, frames, subimgs_all - def manifold2d(self, **kwargs: Union[int, List, str, bool]) -> None: + def manifold2d(self, **kwargs: Union[int, List, str, bool]) -> None: # use torchvision's grid here """ Performs mapping from latent space to data space allowing the learned manifold to be visualized. This works only for 2d latent variable @@ -384,7 +389,8 @@ def manifold2d(self, **kwargs: Union[int, List, str, bool]) -> None: **d (int): grid size **l1 (list): range of 1st latent variable **l2 (list): range of 2nd latent variable - **label(int): label in class-conditioned (r)VAE + **label (int): label in class-conditioned (r)VAE + **disc_idx (int): discrete "class" **cmap (str): color map (Default: gnuplot) **draw_grid (bool): plot semi-transparent grid **origin (str): plot origin (e.g. 'lower') @@ -408,9 +414,14 @@ def manifold2d(self, **kwargs: Union[int, List, str, bool]) -> None: grid_x = norm.ppf(np.linspace(0.05, 0.95, d)) grid_y = norm.ppf(np.linspace(0.05, 0.95, d)) + if self.discrete_dim: + z_disc = np.zeros((sum(self.discrete_dim)))[None] + z_disc[:, kwargs.get("disc_idx", 0)] = 1 for i, yi in enumerate(grid_x): for j, xi in enumerate(grid_y): z_sample = np.array([[xi, yi]]) + if self.discrete_dim: + z_sample = np.concatenate((z_sample, z_disc), -1) if y is not None: imdec = self.decode(z_sample, y) else: @@ -441,6 +452,59 @@ def manifold2d(self, **kwargs: Union[int, List, str, bool]) -> None: fig.savefig(os.path.join(savedir, '{}.png'.format(fname))) plt.close(fig) + def manifold_traversal(self, cont_idx: int, + d: int = 10, + cont_idx_fixed: int = 0, + plot: bool = True, + **kwargs: Union[str, float] + ) -> np.ndarray: + """ + Latent space traversals for joint continuous and discrete + latent representations + """ + if self.discrete_dim is None: + raise TypeError( + "Traversal of latent space is implemented only for joint", + " continuous and discrete latent distributions") + if len(self.in_dim) == 3 and self.in_dim[-1] != 3: + raise ValueError( + "This works only for a single channel and 3-channel images") + num_samples = d**2 + cont_dim = self.z_dim - sum(self.discrete_dim) - self.coord + # Get continuous latent coordinates + samples_cont = np.zeros(shape=(num_samples, cont_dim)) + cont_idx_fixed + cdf_traversal = np.linspace(0.05, 0.95, d) + cont_traversal = norm.ppf(cdf_traversal) + for i in range(d): + for j in range(d): + samples_cont[i * d + j, cont_idx] = cont_traversal[j] + # Get discrete latent coordinates + disc_dim = self.discrete_dim[0] + n = np.arange(0, disc_dim) + n = np.tile(n, d // disc_dim + 1)[:d] + samples_disc = [] + for i in range(d): + samples_disc_i = np.zeros((d, disc_dim)) + samples_disc_i[:, n[i]] = 1 + samples_disc.append(samples_disc_i) + samples_disc = np.concatenate(samples_disc) + # Put them together and pass through a decoder + samples = np.concatenate((samples_cont, samples_disc), -1) + decoded = self.decode(samples) + # Use a built-in torchvision utility to construct a nice grid + decoded = decoded.transpose(0, 3, 1, 2) if decoded.ndim == 4 else decoded[:, None] + grid = make_grid(torch.from_numpy(decoded), + nrow=d, padding=kwargs.get("pad", 2)).numpy() + grid = grid.transpose(1, 2, 0) if len(self.in_dim) == 3 else grid[0] + grid = (grid - grid.min()) / grid.ptp() + if not kwargs.get("keep_square", False) and disc_dim != d: + grid = grid[:(self.in_dim[0]+kwargs.get("pad", 2)) * disc_dim] + if plot: + plt.figure(figsize=(12, 12)) + plt.imshow(grid, cmap='gnuplot', + origin=kwargs.get("origin", "lower")) + return grid + @classmethod def visualize_manifold_learning(cls, frames_dir: str, @@ -461,40 +525,6 @@ def visualize_manifold_learning(cls, duration = kwargs.get("frame_duration", 1) animation_from_png(frames_dir, movie_name, duration, remove_dir=False) - def elbo_fn(self, x: torch.Tensor, x_reconstr: torch.Tensor, - *args: torch.Tensor) -> torch.Tensor: - """ - Calculates ELBO - """ - return vae_loss(self.loss, self.in_dim, x, x_reconstr, *args) - - def forward_compute_elbo(self, - x: torch.Tensor, - y: Optional[torch.Tensor] = None, - mode: str = "train" - ) -> torch.Tensor: - """ - VAE's forward pass with training/test loss computation - """ - x = x.to(self.device) - if mode == "eval": - with torch.no_grad(): - z_mean, z_logsd = self.encoder_net(x) - else: - z_mean, z_logsd = self.encoder_net(x) - z_sd = torch.exp(z_logsd) - z = self.reparameterize(z_mean, z_sd) - if y is not None: - targets = to_onehot(y, self.nb_classes) - z = torch.cat((z, targets), -1) - if mode == "eval": - with torch.no_grad(): - x_reconstr = self.decoder_net(z) - else: - x_reconstr = self.decoder_net(z) - - return self.elbo_fn(x, x_reconstr, z_mean, z_logsd) - def _check_inputs(self, X_train: np.ndarray, y_train: Optional[np.ndarray] = None, @@ -532,64 +562,18 @@ def _check_inputs(self, "The number of classes specified at initialization must be " + "equal the the number of classes in train and test labels") - def fit(self, - X_train: Union[np.ndarray, torch.Tensor], - y_train: Optional[Union[np.ndarray, torch.Tensor]] = None, - X_test: Optional[Union[np.ndarray, torch.Tensor]] = None, - y_test: Optional[Union[np.ndarray, torch.Tensor]] = None, - loss: str = "mse", - **kwargs) -> None: - """ - Trains VAE model - - Args: - X_train: - For images, 3D or 4D stack of training images with dimensions - (n_images, height, width) for grayscale data or - or (n_images, height, width, channels) for multi-channel data. - For spectra, 2D stack of spectra with dimensions (length,) - X_test: - 3D or 4D stack of test images or 2D stack of spectra with - the same dimensions as for the X_train (Default: None) - y_train: - Vector with labels of dimension (n_images,), where n_images - is a number of training images/spectra - y_train: - Vector with labels of dimension (n_images,), where n_images - is a number of test images/spectra - loss: - reconstruction loss function, "ce" or "mse" (Default: "mse") - **filename (str): - file path for saving model aftereach training cycle ("epoch") - """ - self._check_inputs(X_train, y_train, X_test, y_test) - self.compile_trainer( - (X_train, y_train), (X_test, y_test), **kwargs) - self.loss = loss # this part needs to be handled better - - for e in range(self.training_cycles): - elbo_epoch = self.train_epoch() - self.loss_history["train_loss"].append(elbo_epoch) - if self.test_iterator is not None: - elbo_epoch_test = self.evaluate_model() - self.loss_history["test_loss"].append(elbo_epoch_test) - self.print_statistics(e) - self.save_model(self.filename) - return - - def print_statistics(self, e): + def _2torch(self, + X: Union[np.ndarray, torch.Tensor], + y: Union[np.ndarray, torch.Tensor] = None + ) -> torch.Tensor: """ - Prints training and (optionally) test loss after each training cycle + Rules for conversion of numpy arrays to torch tensors """ - if self.test_iterator is not None: - template = 'Epoch: {}/{}, Training loss: {:.4f}, Test loss: {:.4f}' - print(template.format(e+1, self.training_cycles, - -self.loss_history["train_loss"][-1], - -self.loss_history["test_loss"][-1])) - else: - template = 'Epoch: {}/{}, Training loss: {:.4f}' - print(template.format(e+1, self.training_cycles, - -self.loss_history["train_loss"][-1])) + if isinstance(X, np.ndarray): + X = torch.from_numpy(X).float() + if isinstance(y, np.ndarray): + y = torch.from_numpy(y).long() + return X, y class VAE(BaseVAE): @@ -609,6 +593,8 @@ class VAE(BaseVAE): seed for torch and numpy (pseudo-)random numbers generators **conv_encoder (bool): use convolutional layers in encoder + **conv_decoder (bool): + use convolutional layers in decoder **numlayers_encoder (int): number of layers in encoder (Default: 2) **numlayers_decoder (int): @@ -616,7 +602,7 @@ class VAE(BaseVAE): **numhidden_encoder (int): number of hidden units OR conv filters in encoder (Default: 128) **numhidden_decoder (int): - number of hidden units in decoder (Default: 128) + number of hidden units OR conv filters in decoder (Default: 128) Example: @@ -629,7 +615,7 @@ class VAE(BaseVAE): >>> vae.manifold2d(origin="upper", cmap="gnuplot2) One can also pass labels to train a class-conditioned VAE - + >>> # Intitialize model >>> vae = aoi.models.VAE(input_dim, nb_classes=10) >>> # Train @@ -647,103 +633,12 @@ def __init__(self, super(VAE, self).__init__(in_dim, latent_dim, nb_classes, 0, **kwargs) set_train_rng(seed) - def _2torch(self, - X: Union[np.ndarray, torch.Tensor], - y: Union[np.ndarray, torch.Tensor] = None - ) -> torch.Tensor: - if isinstance(X, np.ndarray): - X = torch.from_numpy(X).float() - if isinstance(y, np.ndarray): - y = torch.from_numpy(y).long() - return X, y - - -class rVAE(BaseVAE): - """ - Implements rotationally and translationally invariant - Variational Autoencoder (VAE) based on the idea of "spatial decoder" - by Bepler et al. in arXiv:1909.11663. In addition, this class allows - the implementation of class-conditioned VAE with rotational and - translational variance - - Args: - in_dim: - Input dimensions for image data passed as (heigth, width) - for grayscale data or (height, width, channels) - for multichannel data - latent_dim: - Number of VAE latent dimensions associated with image content - nb_classes: - Number of classes for class-conditional rVAE - translation: - account for xy shifts of image content (Default: True) - seed: - seed for torch and numpy (pseudo-)random numbers generators - **conv_encoder (bool): - use convolutional layers in encoder - **numlayers_encoder (int): - number of layers in encoder (Default: 2) - **numlayers_decoder (int): - number of layers in decoder (Default: 2) - **numhidden_encoder (int): - number of hidden units OR conv filters in encoder (Default: 128) - **numhidden_decoder (int): - number of hidden units in decoder (Default: 128) - **skip (bool): - uses generative skip model with residual paths between - latents and decoder layers (Default: False) - - Example: - - >>> input_dim = (28, 28) # intput dimensions - >>> # Intitialize model - >>> rvae = aoi.models.rVAE(input_dim) - >>> # Train - >>> rvae.fit(imstack_train, training_cycles=100, - batch_size=100, rotation_prior=np.pi/2) - >>> rvae.manifold2d(origin="upper", cmap="gnuplot2") - - One can also pass labels to train a class-conditioned rVAE - - >>> # Intitialize model - >>> rvae = aoi.models.rVAE(input_dim, nb_classes=10) - >>> # Train - >>> rvae.fit(imstack_train, labels_train, training_cycles=100, - >>> batch_size=100, rotation_prior=np.pi/2) - >>> # Visualize learned manifold for class 1 - >>> rvae.manifold2d(label=1, origin="upper", cmap="gnuplot2") - """ - - def __init__(self, - in_dim: int = None, - latent_dim: int = 2, - nb_classes: int = 0, - translation: bool = True, - seed: int = 0, - **kwargs: Union[int, bool, str] - ) -> None: - """ - Initializes rVAE model - """ - coord = 3 if translation else 1 # xy translations and/or rotation - args = (in_dim, latent_dim, nb_classes, coord) - super(rVAE, self).__init__(*args, **kwargs) - set_train_rng(seed) - self.x_coord = None - self.translation = translation - self.dx_prior = None - self.phi_prior = None - - def elbo_fn(self, - x: torch.Tensor, - x_reconstr: torch.Tensor, - *args: torch.Tensor, - **kwargs: float - ) -> torch.Tensor: + def elbo_fn(self, x: torch.Tensor, x_reconstr: torch.Tensor, + *args: torch.Tensor) -> torch.Tensor: """ - Computes ELBO + Calculates ELBO """ - return rvae_loss(self.loss, self.in_dim, x, x_reconstr, *args, **kwargs) + return vae_loss(self.loss, self.in_dim, x, x_reconstr, *args) def forward_compute_elbo(self, x: torch.Tensor, @@ -751,9 +646,9 @@ def forward_compute_elbo(self, mode: str = "train" ) -> torch.Tensor: """ - rVAE's forward pass with training/test loss computation + VAE's forward pass with training/test loss computation """ - x_coord_ = self.x_coord.expand(x.size(0), *self.x_coord.size()) + x = x.to(self.device) if mode == "eval": with torch.no_grad(): z_mean, z_logsd = self.encoder_net(x) @@ -761,110 +656,61 @@ def forward_compute_elbo(self, z_mean, z_logsd = self.encoder_net(x) z_sd = torch.exp(z_logsd) z = self.reparameterize(z_mean, z_sd) - phi = z[:, 0] # angle - if self.translation: - dx = z[:, 1:3] # translation - dx = (dx * self.dx_prior).unsqueeze(1) - z = z[:, 3:] # image content - else: - dx = 0 # no translation - z = z[:, 1:] # image content - if y is not None: targets = to_onehot(y, self.nb_classes) z = torch.cat((z, targets), -1) - - x_coord_ = transform_coordinates(x_coord_, phi, dx) if mode == "eval": with torch.no_grad(): - x_reconstr = self.decoder_net(x_coord_, z) + x_reconstr = self.decoder_net(z) else: - x_reconstr = self.decoder_net(x_coord_, z) + x_reconstr = self.decoder_net(z) - return self.elbo_fn(x, x_reconstr, z_mean, z_logsd, phi_prior=self.phi_prior) + return self.elbo_fn(x, x_reconstr, z_mean, z_logsd) def fit(self, - X_train: Optional[Union[np.ndarray, torch.Tensor]], + X_train: Union[np.ndarray, torch.Tensor], y_train: Optional[Union[np.ndarray, torch.Tensor]] = None, X_test: Optional[Union[np.ndarray, torch.Tensor]] = None, y_test: Optional[Union[np.ndarray, torch.Tensor]] = None, loss: str = "mse", **kwargs) -> None: """ - Trains rVAE model + Trains VAE model Args: X_train: - 3D or 4D stack of training images with dimensions + For images, 3D or 4D stack of training images with dimensions (n_images, height, width) for grayscale data or - or (n_images, height, width, channels) for multi-channel data + or (n_images, height, width, channels) for multi-channel data. + For spectra, 2D stack of spectra with dimensions (length,) X_test: - 3D or 4D stack of test images with the same dimensions - as for the X_train (Default: None) + 3D or 4D stack of test images or 2D stack of spectra with + the same dimensions as for the X_train (Default: None) y_train: Vector with labels of dimension (n_images,), where n_images - is a number of training images + is a number of training images/spectra y_train: Vector with labels of dimension (n_images,), where n_images - is a number of test images + is a number of test images/spectra loss: reconstruction loss function, "ce" or "mse" (Default: "mse") - **translation_prior (float): - translation prior - **rotation_prior (float): - rotational prior **filename (str): file path for saving model aftereach training cycle ("epoch") - **recording (bool): - saves a learned 2d manifold at each training step """ self._check_inputs(X_train, y_train, X_test, y_test) - self.x_coord = imcoordgrid(X_train.shape[1:]).to(self.device) - self.dx_prior = kwargs.get("translation_prior", 0.1) - self.phi_prior = kwargs.get("rotation_prior", 0.1) self.compile_trainer( (X_train, y_train), (X_test, y_test), **kwargs) self.loss = loss # this part needs to be handled better - self.recording = kwargs.get("recording", False) - + if self.loss == "ce": + self.sigmoid_out = True # Use sigmoid layer for "prediction" stage + self.metadict["sigmoid_out"] = True for e in range(self.training_cycles): + self.current_epoch = e elbo_epoch = self.train_epoch() self.loss_history["train_loss"].append(elbo_epoch) if self.test_iterator is not None: elbo_epoch_test = self.evaluate_model() self.loss_history["test_loss"].append(elbo_epoch_test) self.print_statistics(e) - if self.recording and self.z_dim in [3, 5]: - self.manifold2d(savefig=True, filename=str(e)) - self.save_model(self.filename) - if self.recording and self.z_dim in [3, 5]: - self.visualize_manifold_learning("./vae_learning") - - def _2torch(self, - X: Union[np.ndarray, torch.Tensor], - y: Union[np.ndarray, torch.Tensor] = None - ) -> torch.Tensor: - """ - Transforms a pair numpy arrays (images, labels) to torch tensors - """ - if isinstance(X, np.ndarray): - X = torch.from_numpy(X).float() - if isinstance(y, np.ndarray): - y = torch.from_numpy(y).long() - return X, y - - -def to_onehot(idx: torch.Tensor, n: int) -> torch.Tensor: # move to utils! - """ - One-hot encoding of label - """ - if torch.max(idx).item() >= n: - raise AssertionError( - "Labelling must start from 0 and " - "maximum label value must be less than total number of classes") - if idx.dim() == 1: - idx = idx.unsqueeze(1) - device_ = 'cuda' if torch.cuda.is_available() else 'cpu' - onehot = torch.zeros(idx.size(0), n, device=device_) - onehot.scatter_(1, idx, 1) - return onehot + self.save_model(self.filename) + return diff --git a/atomai/models/loaders.py b/atomai/models/loaders.py index c302805a..7af23f99 100644 --- a/atomai/models/loaders.py +++ b/atomai/models/loaders.py @@ -14,11 +14,11 @@ import torch from .segmentor import Segmentor from .imspec import ImSpec -from .vae import BaseVAE +from .dgm import BaseVAE, VAE, rVAE, jrVAE, jVAE from ..utils import average_weights -def load_model(filepath: str) -> Union[Segmentor, BaseVAE, ImSpec]: +def load_model(filepath: str) -> Union[Segmentor, Union[VAE, rVAE, jrVAE, jVAE], ImSpec]: """ Loads trained AtomAI models @@ -67,8 +67,10 @@ def load_seg_model(meta_dict: Dict[str, torch.Tensor]) -> Type[Segmentor]: model_name = meta_dict.pop("model") nb_classes = meta_dict.pop("nb_classes") weights = meta_dict.pop("weights") + optimizer = meta_dict.pop("optimizer") model = Segmentor(model_name, nb_classes, **meta_dict) model.net.load_state_dict(weights) + model.optimizer = optimizer model.net.eval() return model @@ -89,8 +91,10 @@ def load_imspec_model(meta_dict: Dict[str, torch.Tensor]) -> Type[ImSpec]: out_dim = meta_dict.pop("out_dim") z_dim = meta_dict.pop("latent_dim") weights = meta_dict.pop("weights") + optimizer = meta_dict.pop("optimizer") model = ImSpec(in_dim, out_dim, z_dim, **meta_dict) model.net.load_state_dict(weights) + model.optimizer = optimizer model.net.eval() return model @@ -111,11 +115,22 @@ def load_vae_model(meta_dict: Dict[str, torch.Tensor]) -> Type[BaseVAE]: latent_dim = meta_dict.pop("latent_dim") encoder_weights = meta_dict.pop("encoder") decoder_weights = meta_dict.pop("decoder") - m = BaseVAE(in_dim, latent_dim, **meta_dict) + coord = meta_dict.pop("coord") + optimizer = meta_dict.pop("optimizer") + if coord: + translate = True if coord == 3 else False + model = jrVAE if meta_dict["discrete_dim"] else rVAE + m = model(in_dim, latent_dim, translation=translate, **meta_dict) + else: + model = jVAE if meta_dict["discrete_dim"] else VAE + m = model(in_dim, latent_dim, **meta_dict) + if meta_dict["discrete_dim"]: + m.kdict_["num_iter"] = meta_dict.get("num_iter", 0) m.encoder_net.load_state_dict(encoder_weights) m.encoder_net.eval() m.decoder_net.load_state_dict(decoder_weights) m.decoder_net.eval() + m.optim = optimizer return m diff --git a/atomai/models/segmentor.py b/atomai/models/segmentor.py index 3d68b332..1b4b47cb 100644 --- a/atomai/models/segmentor.py +++ b/atomai/models/segmentor.py @@ -13,7 +13,7 @@ class Segmentor(SegTrainer): Args: model: - Type of model to train: 'Unet', 'Uplusnet' or 'dilnet' (Default: 'Unet'). + Type of model to train: 'Unet', 'ResHedNet' or 'dilnet' (Default: 'Unet'). See atomai.nets for more details. One can also pass here a custom fully convolutional neural network model. nb_classes: diff --git a/atomai/nets/ed.py b/atomai/nets/ed.py index 1b0798ad..3d814ba9 100644 --- a/atomai/nets/ed.py +++ b/atomai/nets/ed.py @@ -1,5 +1,5 @@ """ -imspec.py +ed.py ========= Encoder and decoder modules for VAE/VED and im2spec/spec2im models @@ -8,7 +8,7 @@ """ -from typing import Tuple, Type, Union, Dict +from typing import Tuple, Type, Union, Dict, List, Optional import numpy as np import torch @@ -230,7 +230,7 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: class convEncoderNet(nn.Module): """ - Convolutional rncoder/inference network (for variational autoencoder) + Convolutional encoder/inference network (for variational autoencoder) Args: in_dim: @@ -245,13 +245,16 @@ class convEncoderNet(nn.Module): hidden_dim: number of neurons in each fully connnected layer (for mlp=True) or number of filters in each convolutional layer (for mlp=False) + **softplus_out (bool): + Optionally applies a softplus activation to the output associated + with standard deviation of the encoded distribution """ def __init__(self, in_dim: Tuple[int], latent_dim: int = 2, num_layers: int = 2, hidden_dim: int = 32, - **kwargs: float + **kwargs: Union[float, bool] ) -> None: """ Initializes network parameters @@ -269,6 +272,7 @@ def __init__(self, self.reshape_ = hidden_dim * np.product(in_dim[:2]) self.fc11 = nn.Linear(self.reshape_, latent_dim) self.fc12 = nn.Linear(self.reshape_, latent_dim) + self._out = nn.Softplus() if kwargs.get("softplus_out") else lambda x: x def forward(self, x: torch.Tensor) -> Tuple[torch.Tensor]: """ @@ -281,7 +285,7 @@ def forward(self, x: torch.Tensor) -> Tuple[torch.Tensor]: x = self.conv(x) x = x.reshape(-1, self.reshape_) z_mu = self.fc11(x) - z_logstd = self.fc12(x) + z_logstd = self._out(self.fc12(x)) return z_mu, z_logstd @@ -302,12 +306,16 @@ class fcEncoderNet(nn.Module): hidden_dim: number of neurons in each fully connnected layer (for mlp=True) or number of filters in each convolutional layer (for mlp=False) + **softplus_out (bool): + Optionally applies a softplus activation to the output associated + with standard deviation of the encoded distribution """ def __init__(self, in_dim: Tuple[int], latent_dim: int = 2, num_layers: int = 2, hidden_dim: int = 32, + **kwargs: bool ) -> None: """ Initializes network parameters @@ -321,6 +329,7 @@ def __init__(self, self.reshape_ = hidden_dim self.fc11 = nn.Linear(self.reshape_, latent_dim) self.fc12 = nn.Linear(self.reshape_, latent_dim) + self._out = nn.Softplus() if kwargs.get("softplus_out") else lambda x: x def forward(self, x: torch.Tensor): """ @@ -330,10 +339,135 @@ def forward(self, x: torch.Tensor): x = self.dense(x) x = x.reshape(-1, self.reshape_) z_mu = self.fc11(x) - z_logstd = self.fc12(x) + z_logstd = self._out(self.fc12(x)) return z_mu, z_logstd +class jfcEncoderNet(nn.Module): + """ + Encoder/inference network (for variational autoencoder) + + Args: + in_dim: + Input dimensions. + For images, it is (height, width) or (height, width, channels). + For spectra, it is (length,) + latent_dim: + number of latent dimensions + (the first 3 latent dimensions are angle & translations by default) + num_layers: + number of NN layers + hidden_dim: + number of neurons in each fully connnected layer (for mlp=True) + or number of filters in each convolutional layer (for mlp=False) + **softplus_out (bool): + Optionally applies a softplus activation to the output associated + with standard deviation of the encoded distribution + """ + def __init__(self, + in_dim: Tuple[int], + latent_dim: int = 2, + discrete_dim: List = [1], + num_layers: int = 2, + hidden_dim: int = 32, + **kwargs: bool + ) -> None: + """ + Initializes network parameters + """ + super(jfcEncoderNet, self).__init__() + dense = [] + for i in range(num_layers): + input_dim = np.product(in_dim) if i == 0 else hidden_dim + dense.extend([nn.Linear(input_dim, hidden_dim), nn.Tanh()]) + self.dense = nn.Sequential(*dense) + self.reshape_ = hidden_dim + self.fc11 = nn.Linear(self.reshape_, latent_dim) + self.fc12 = nn.Linear(self.reshape_, latent_dim) + fc13 = [] + for disc in discrete_dim: + fc13.append(nn.Linear(self.reshape_, disc)) + self.fc13 = nn.ModuleList(fc13) + self._out = nn.Softplus() if kwargs.get("softplus_out") else lambda x: x + + def forward(self, x: torch.Tensor): + """ + Forward pass + """ + x = x.reshape(-1, np.product(x.size()[1:])) + x = self.dense(x) + x = x.reshape(-1, self.reshape_) + encoded = [self.fc11(x), self._out(self.fc12(x))] + for fc_ in self.fc13: + encoded.append(F.softmax(fc_(x), dim=1)) + return encoded + + +class jconvEncoderNet(nn.Module): + """ + Convolutional encoder/inference network for joint continuous + and discrete distributions (for variational autoencoder) + + Args: + in_dim: + Input dimensions. + For images, it is (height, width) or (height, width, channels). + For spectra, it is (length,) + latent_dim: + number of latent dimensions + (the first 3 latent dimensions are angle & translations by default) + num_layers: + number of NN layers + hidden_dim: + number of neurons in each fully connnected layer (for mlp=True) + or number of filters in each convolutional layer (for mlp=False) + **softplus_out (bool): + Optionally applies a softplus activation to the output associated + with standard deviation of the encoded distribution + """ + def __init__(self, + in_dim: Tuple[int], + latent_dim: int = 2, + discrete_dim: List = [1], + num_layers: int = 2, + hidden_dim: int = 32, + **kwargs: Union[float, bool] + ) -> None: + """ + Initializes network parameters + """ + super(jconvEncoderNet, self).__init__() + if len(in_dim) not in (1, 2, 3): + raise ValueError( + "The input dimensions must be (length,) for 1D data and " + + "(height, width) or (height, width, channel) for 2D data") + dim = 2 if len(in_dim) > 1 else 1 + c = in_dim[-1] if len(in_dim) > 2 else 1 + self.conv = ConvBlock( + dim, num_layers, c, hidden_dim, + lrelu_a=kwargs.get("lrelu_a", 0.1)) + self.reshape_ = hidden_dim * np.product(in_dim[:2]) + self.fc11 = nn.Linear(self.reshape_, latent_dim) + self.fc12 = nn.Linear(self.reshape_, latent_dim) + fc13 = [] + for disc in discrete_dim: + fc13.append(nn.Linear(self.reshape_, disc)) + self.fc13 = nn.ModuleList(fc13) + self._out = nn.Softplus() if kwargs.get("softplus_out") else lambda x: x + + def forward(self, x: torch.Tensor) -> Dict[str, torch.Tensor]: + """ + Forward pass + """ + x = x.unsqueeze(1) if x.ndim in (2, 3) else x.permute(0, -1, 1, 2) + x = self.conv(x) + x = x.reshape(-1, self.reshape_) + encoded = [self.fc11(x), self._out(self.fc12(x))] + for fc_ in self.fc13: + encoded.append(F.softmax(fc_(x), dim=1)) + return encoded + + class convDecoderNet(nn.Module): """ Convolutional decoder network (for variational autoencoder) @@ -355,7 +489,7 @@ def __init__(self, latent_dim: int, num_layers: int = 2, hidden_dim: int = 32, - num_classes: int = 0, + num_classes: int = 0, # num_classes is redundant (just pass latent_dim = latent_dim + nb_classes in init_vae_nets) **kwargs: float) -> None: """ Initializes network parameters @@ -415,7 +549,8 @@ def __init__(self, latent_dim: int, num_layers: int = 2, hidden_dim: int = 32, - num_classes: int = 0) -> None: + num_classes: int = 0 + ) -> None: # num_classes is redundant (just pass latent_dim = latent_dim + nb_classes in init_vae_nets) """ Initializes network parameters """ @@ -470,7 +605,8 @@ def __init__(self, num_layers: int, hidden_dim: int, skip: bool = False, - num_classes: int = 0) -> None: + num_classes: int = 0 # num_classes is redundant (just pass latent_dim = latent_dim + nb_classes in init_vae_nets) + ) -> None: """ Initializes network parameters """ @@ -591,8 +727,9 @@ def init_imspec_model(in_dim: Tuple[int], def init_VAE_nets(in_dim: Tuple[int], latent_dim: int, - coord: int, - nb_classes: int, + coord: int = 0, + discrete_dim: Optional[List] = None, + nb_classes: int = 0, **kwargs ) -> Tuple[Type[nn.Module], Type[nn.Module], Dict[str, Union[int, bool]]]: """ @@ -606,19 +743,32 @@ def init_VAE_nets(in_dim: Tuple[int], numhidden_e = kwargs.get("numhidden_encoder", 128) numhidden_d = kwargs.get("numhidden_decoder", 128) skip = kwargs.get("skip", False) + sigmoid_out = kwargs.get("sigmoid_out", False) + softplus_out = kwargs.get("softplus_out") + + discrete_dim_ = 0 + if discrete_dim: + discrete_dim_ = sum(discrete_dim) if not coord: dnet = convDecoderNet if conv_d else fcDecoderNet decoder_net = dnet( - in_dim, latent_dim, numlayers_d, numhidden_d, + in_dim, latent_dim+discrete_dim_, numlayers_d, numhidden_d, nb_classes) else: decoder_net = rDecoderNet( - in_dim, latent_dim, numlayers_d, numhidden_d, + in_dim, latent_dim+discrete_dim_, numlayers_d, numhidden_d, skip, nb_classes) - enet = convEncoderNet if conv_e else fcEncoderNet - encoder_net = enet( - in_dim, latent_dim + coord, numlayers_e, numhidden_e) + if not discrete_dim: + enet = convEncoderNet if conv_e else fcEncoderNet + encoder_net = enet( + in_dim, latent_dim + coord, numlayers_e, numhidden_e, + softplus_out=softplus_out) + else: + enet = jconvEncoderNet if conv_e else jfcEncoderNet + encoder_net = enet( + in_dim, latent_dim + coord, discrete_dim, numlayers_e, numhidden_e, + softplus_out=softplus_out) meta_state_dict = { "model_type": "vae", @@ -631,7 +781,10 @@ def init_VAE_nets(in_dim: Tuple[int], "numhidden_encoder": numhidden_e, "numhidden_decoder": numhidden_d, "skip": skip, - "nb_classes": nb_classes + "nb_classes": nb_classes, + "discrete_dim": discrete_dim, + "sigmoid_out": sigmoid_out, + "softplus_out": softplus_out } if not coord: meta_state_dict["conv_decoder"] = conv_d diff --git a/atomai/trainers/etrainer.py b/atomai/trainers/etrainer.py index 42599a1d..fd6ba5f8 100644 --- a/atomai/trainers/etrainer.py +++ b/atomai/trainers/etrainer.py @@ -95,6 +95,7 @@ def train_baseline(self, self._reset_rng(seed) self._reset_weights() self._reset_training_history() + self._delete_optimizer() (X_train, y_train, X_test, y_test) = self.preprocess_train_data( X_train, y_train, X_test, y_test) @@ -219,6 +220,7 @@ def train_ensemble_from_baseline(self, self.net.load_state_dict(basemodel_state_dict) self._reset_rng(i+2) self._reset_training_history() + self._delete_optimizer() self.compile_trainer( # Note that here we reinitialize optimizer (X_train, y_train, X_test, y_test), batch_seed=i+2, **self.kdict) @@ -409,6 +411,7 @@ def train_baseline(self, self._reset_rng(seed) self._reset_weights() self._reset_training_history() + self._delete_optimizer() self.compile_trainer( (X_train, y_train, X_test, y_test), **self.kdict) diff --git a/atomai/trainers/trainer.py b/atomai/trainers/trainer.py index c11a396d..72d50903 100644 --- a/atomai/trainers/trainer.py +++ b/atomai/trainers/trainer.py @@ -109,6 +109,12 @@ def _reset_training_history(self) -> None: self.loss_acc = {"train_loss": [], "test_loss": [], "train_accuracy": [], "test_accuracy": []} + def _delete_optimizer(self) -> None: + """ + Sets optimizer to None. + """ + self.optimizer = None + def set_data(self, X_train: Union[torch.Tensor, np.ndarray], y_train: Union[torch.Tensor, np.ndarray], @@ -509,10 +515,11 @@ def compile_trainer(self, self.perturb_weights = {"a": .01, "gamma": 1.5, "e_p": e_p} params = self.net.parameters() - if optimizer is None: - self.optimizer = torch.optim.Adam(params, lr=1e-3) - else: - self.optimizer = optimizer(params) + if self.optimizer is None: + if optimizer is None: + self.optimizer = torch.optim.Adam(params, lr=1e-3) + else: + self.optimizer = optimizer(params) self.criterion = self.get_loss_fn(loss, self.nb_classes) if not self.full_epoch: @@ -637,7 +644,7 @@ def __init__(self, "No GPU found. The training can be EXTREMELY slow", UserWarning) self.meta_state_dict["weights"] = self.net.state_dict() - self.meta_state_dict["optimizer"] = self.optimizer + #self.meta_state_dict["optimizer"] = self.optimizer def set_data(self, X_train: Tuple[np.ndarray, torch.Tensor], @@ -765,7 +772,7 @@ def __init__(self, self.net.to(self.device) self.meta_state_dict["weights"] = self.net.state_dict() - self.meta_state_dict["optimizer"] = self.optimizer + #self.meta_state_dict["optimizer"] = self.optimizer def set_data(self, X_train: Union[np.ndarray, torch.Tensor], diff --git a/atomai/trainers/vitrainer.py b/atomai/trainers/vitrainer.py index fd3176f8..f59a094c 100644 --- a/atomai/trainers/vitrainer.py +++ b/atomai/trainers/vitrainer.py @@ -8,10 +8,12 @@ """ -from typing import Tuple, Type, Optional, Union, Callable -import torch +from typing import Callable, Optional, Tuple, Type, Union + import numpy as np -from ..utils import set_train_rng, get_array_memsize +import torch + +from ..utils import get_array_memsize, reset_bnorm, set_train_rng, weights_init class viBaseTrainer: @@ -28,7 +30,9 @@ def __init__(self): self.decoder_net = None self.train_iterator = None self.test_iterator = None + self.aux_model_params = [] self.optim = None + self.current_epoch = 0 self.metadict = {} self.loss_history = {"train_loss": [], "test_loss": []} self.filename = "model" @@ -47,6 +51,24 @@ def set_model(self, self.encoder_net.to(self.device) self.decoder_net.to(self.device) + def set_encoder(self, + encoder_net: Type[torch.nn.Module] + ) -> None: + """ + Sets an encoder network only + """ + self.encoder_net = encoder_net + self.encoder_net.to(self.device) + + def set_decoder(self, + decoder_net: Type[torch.nn.Module] + ) -> None: + """ + Sets a decoder network only + """ + self.decoder_net = decoder_net + self.decoder_net.to(self.device) + def set_data(self, X_train: Union[torch.Tensor, np.ndarray], y_train: Union[torch.Tensor, np.ndarray] = None, @@ -119,6 +141,35 @@ def forward_compute_elbo(self): """ raise NotImplementedError + def _reset_rng(self, seed: int) -> None: + """ + (re)sets seeds for pytorch and numpy random number generators + """ + set_train_rng(seed) + + def _reset_weights(self) -> None: + """ + Resets weights of convolutional and linear NN layers + using Xavier initialization + """ + self.encoder_net.apply(weights_init) + self.encoder_net.apply(reset_bnorm) + self.decoder_net.apply(weights_init) + self.decoder_net.apply(reset_bnorm) + + def _reset_training_history(self) -> None: + """ + Empties training/test losses and accuracies + (can be useful for ensemble training) + """ + self.loss_history = {"train_loss": [], "test_loss": []} + + def _delete_optimizer(self) -> None: + """ + Sets optimizer to None. + """ + self.optim = None + def compile_trainer(self, train_data: Tuple[Union[torch.Tensor, np.ndarray]], test_data: Tuple[Union[torch.Tensor, np.ndarray]] = None, @@ -157,12 +208,16 @@ def compile_trainer(self, *train_data, *test_data, memory_alloc=alloc) else: self.set_data(*train_data, memory_alloc=alloc) + params = list(self.decoder_net.parameters()) +\ list(self.encoder_net.parameters()) - if optimizer is None: - self.optim = torch.optim.Adam(params, lr=1e-4) - else: - self.optim = optimizer(params) + for aux_param in self.aux_model_params: + params.extend(list(aux_param)) + if self.optim is None: + if optimizer is None: + self.optim = torch.optim.Adam(params, lr=1e-4) + else: + self.optim = optimizer(params) self.filename = kwargs.get("filename", "./model") @classmethod @@ -171,13 +226,69 @@ def reparameterize(cls, z_sd: torch.Tensor ) -> torch.Tensor: """ - Reparameterization trick + Reparameterization trick for continuous distributions """ batch_dim = z_mean.size(0) z_dim = z_mean.size(1) eps = z_mean.new(batch_dim, z_dim).normal_() return z_mean + z_sd * eps + @classmethod + def reparameterize_discrete(cls, + alpha: torch.Tensor, + tau: float): + """ + Reparameterization trick for discrete gumbel-softmax distributions + """ + eps = 1e-12 + su = alpha.new(alpha.size()).uniform_() + gumbel = -torch.log(-torch.log(su + eps) + eps) + log_alpha = torch.log(alpha + eps) + logit = (log_alpha + gumbel) / tau + return torch.nn.functional.softmax(logit, dim=1) + + def kld_normal(self, + z: torch.Tensor, + q_param: Tuple[torch.Tensor], + p_param: Optional[Tuple[torch.Tensor]] = None + ) -> torch.Tensor: + """ + Calculates KL divergence term between two normal distributions + or (if p_param = None) between normal and standard normal distributions + + Args: + z: latent vector (reparametrized) + q_param: tuple with mean and SD of the 1st distribution + p_param: tuple with mean and SD of the 2nd distribution (optional) + """ + qz = self.log_normal(z, *q_param) + if p_param is None: + pz = self.log_unit_normal(z) + else: + pz = self.log_normal(z, *p_param) + return qz - pz + + @classmethod + def log_normal(cls, + x: torch.Tensor, + mu: torch.Tensor, + log_sd: torch.Tensor + ) -> torch.Tensor: + """ + Computes log-pdf for a normal distribution + """ + log_pdf = (-0.5 * np.log(2 * np.pi) - log_sd - + (x - mu)**2 / (2 * torch.exp(log_sd)**2)) + return torch.sum(log_pdf, dim=-1) + + @classmethod + def log_unit_normal(cls, x: torch.Tensor) -> torch.Tensor: + """ + Computes log-pdf of a unit normal distribution + """ + log_pdf = -0.5 * (np.log(2 * np.pi) + x ** 2) + return torch.sum(log_pdf, dim=-1) + def train_epoch(self): """ Trains a single epoch @@ -233,6 +344,20 @@ def evaluate_model(self): elbo_epoch_test += delta / c return elbo_epoch_test + def print_statistics(self, e): + """ + Prints training and (optionally) test loss after each training cycle + """ + if self.test_iterator is not None: + template = 'Epoch: {}/{}, Training loss: {:.4f}, Test loss: {:.4f}' + print(template.format(e+1, self.training_cycles, + -self.loss_history["train_loss"][-1], + -self.loss_history["test_loss"][-1])) + else: + template = 'Epoch: {}/{}, Training loss: {:.4f}' + print(template.format(e+1, self.training_cycles, + -self.loss_history["train_loss"][-1])) + def save_model(self, *args: str) -> None: """ Saves trained weights and the key model parameters @@ -269,4 +394,3 @@ def load_weights(self, filepath: str) -> None: self.encoder_net.eval() self.decoder_net.load_state_dict(decoder_weights) self.decoder_net.eval() - diff --git a/atomai/utils/coords.py b/atomai/utils/coords.py index cba29d65..440e175f 100644 --- a/atomai/utils/coords.py +++ b/atomai/utils/coords.py @@ -34,6 +34,16 @@ def find_com(image_data: np.ndarray) -> np.ndarray: return coordinates +def grid2xy(X1: torch.Tensor, X2: torch.Tensor) -> torch.Tensor: + """ + Maps (M, N) grid to (M*N, 2) xy coordinates + """ + X = torch.cat((X1[None], X2[None]), 0) + d0, d1 = X.shape[0], X.shape[1] * X.shape[2] + X = X.reshape(d0, d1).T + return X + + def imcoordgrid(im_dim: Tuple) -> torch.Tensor: """ Returns a grid with pixel coordinates (used e.g. in rVAE) @@ -41,9 +51,7 @@ def imcoordgrid(im_dim: Tuple) -> torch.Tensor: xx = torch.linspace(-1, 1, im_dim[0]) yy = torch.linspace(1, -1, im_dim[1]) x0, x1 = torch.meshgrid(xx, yy) - x_coord = torch.stack( - [x0.T.flatten(), x1.T.flatten()], axis=1) - return x_coord + return grid2xy(x0, x1) def transform_coordinates(coord: Union[np.ndarray, torch.Tensor], @@ -123,7 +131,7 @@ def get_nn_distances(coordinates: Union[Dict[int, np.ndarray], np.ndarray], upper_bound (float or int, non-negative): Upper distance bound for Query the kd-tree for nearest neighbors. Only distances below this value will be counted. - + Returns: Tuple with list of :math:`atoms \\times nn` arrays of distances to nearest neighbors and list of :math:`atoms \\times (nn+1) \\times 3` diff --git a/atomai/utils/preproc.py b/atomai/utils/preproc.py index 0e79f5c6..80e11402 100644 --- a/atomai/utils/preproc.py +++ b/atomai/utils/preproc.py @@ -582,3 +582,19 @@ def data_split(X_train: np.ndarray, " Choose between 'torch_float', 'torch_float_long' and 'numpy'") return X_train, y_train, X_test, y_test + + +def to_onehot(idx: torch.Tensor, n: int) -> torch.Tensor: + """ + One-hot encoding of label + """ + if torch.max(idx).item() >= n: + raise AssertionError( + "Labelling must start from 0 and " + "maximum label value must be less than total number of classes") + if idx.dim() == 1: + idx = idx.unsqueeze(1) + device_ = 'cuda' if torch.cuda.is_available() else 'cpu' + onehot = torch.zeros(idx.size(0), n, device=device_) + onehot.scatter_(1, idx, 1) + return onehot diff --git a/docs/source/atomai_models.rst b/docs/source/atomai_models.rst index d19091ad..37e7a4be 100644 --- a/docs/source/atomai_models.rst +++ b/docs/source/atomai_models.rst @@ -35,6 +35,24 @@ Rotational Variational Autoencoder (rVAE) :member-order: bysource :show-inheritance: +Joint Variational Autoencoder (jVAE) +------------------------------------------ +.. autoclass:: atomai.models.jVAE + :members: + :inherited-members: + :undoc-members: + :member-order: bysource + :show-inheritance: + +Joint Rotational Variational Autoencoder (jrVAE) +------------------------------------------------ +.. autoclass:: atomai.models.jrVAE + :members: + :inherited-members: + :undoc-members: + :member-order: bysource + :show-inheritance: + Load trained models -------------------- .. autofunction:: atomai.models.load_model diff --git a/docs/source/conf.py b/docs/source/conf.py index 39c04237..6be567f9 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -14,7 +14,7 @@ import sys sys.path.insert(0, os.path.abspath('../../')) -autodoc_mock_imports = ['torch', 'torch.nn', 'torch.nn.functional'] +autodoc_mock_imports = ['torch', 'torch.nn', 'torch.nn.functional', 'torchvision'] # -- Project information ----------------------------------------------------- diff --git a/docs/source/nets.rst b/docs/source/nets.rst index af10b093..eebd4d49 100644 --- a/docs/source/nets.rst +++ b/docs/source/nets.rst @@ -16,6 +16,18 @@ Fully convolutional neural networks :member-order: bysource :show-inheritance: +.. autoclass:: atomai.nets.ResHedNet + :members: + :undoc-members: + :member-order: bysource + :show-inheritance: + +.. autoclass:: atomai.nets.SegResNet + :members: + :undoc-members: + :member-order: bysource + :show-inheritance: + Neural Networks for VAE ------------------------ .. autoclass:: atomai.nets.fcEncoderNet @@ -84,6 +96,18 @@ Building blocks :show-inheritance: .. autoclass:: atomai.nets.UpsampleBlock + :members: + :undoc-members: + :member-order: bysource + :show-inheritance: + +.. autoclass:: atomai.nets.ResBlock + :members: + :undoc-members: + :member-order: bysource + :show-inheritance: + +.. autoclass:: atomai.nets.ResModule :members: :undoc-members: :member-order: bysource diff --git a/examples/notebooks/atomai_custom_model.ipynb b/examples/notebooks/atomai_custom_model.ipynb index 50e198ce..4ff45b27 100644 --- a/examples/notebooks/atomai_custom_model.ipynb +++ b/examples/notebooks/atomai_custom_model.ipynb @@ -7,7 +7,7 @@ "provenance": [], "collapsed_sections": [], "machine_shape": "hm", - "authorship_tag": "ABX9TyMDhb6olDGMcOdQlUgfkzId", + "authorship_tag": "ABX9TyN2JAkGpTdYD94LZZH1Drup", "include_colab_link": true }, "kernelspec": { @@ -80,58 +80,58 @@ "base_uri": "https://localhost:8080/" }, "id": "rD_4eU-L7mBE", - "outputId": "10f8bc42-da29-4b1f-e063-ef1b04c31106" + "outputId": "d4110f72-3e92-4bb4-ecb9-fbd33694dde5" }, "source": [ "!pip install atomai" ], - "execution_count": null, + "execution_count": 1, "outputs": [ { "output_type": "stream", "text": [ "Collecting atomai\n", - "\u001b[?25l Downloading https://files.pythonhosted.org/packages/ec/96/052c840e2bf8a28f3efca99853ce719ab40daad5163ea08df45330bacbfc/atomai-0.6.0-py3-none-any.whl (104kB)\n", - "\r\u001b[K |███▏ | 10kB 20.2MB/s eta 0:00:01\r\u001b[K |██████▎ | 20kB 26.0MB/s eta 0:00:01\r\u001b[K |█████████▌ | 30kB 25.2MB/s eta 0:00:01\r\u001b[K |████████████▋ | 40kB 18.5MB/s eta 0:00:01\r\u001b[K |███████████████▊ | 51kB 15.3MB/s eta 0:00:01\r\u001b[K |███████████████████ | 61kB 17.3MB/s eta 0:00:01\r\u001b[K |██████████████████████ | 71kB 15.3MB/s eta 0:00:01\r\u001b[K |█████████████████████████▏ | 81kB 16.0MB/s eta 0:00:01\r\u001b[K |████████████████████████████▍ | 92kB 15.0MB/s eta 0:00:01\r\u001b[K |███████████████████████████████▌| 102kB 13.8MB/s eta 0:00:01\r\u001b[K |████████████████████████████████| 112kB 13.8MB/s \n", - "\u001b[?25hRequirement already satisfied: scikit-image==0.16.2 in /usr/local/lib/python3.6/dist-packages (from atomai) (0.16.2)\n", - "Requirement already satisfied: numpy>=1.18.5 in /usr/local/lib/python3.6/dist-packages (from atomai) (1.18.5)\n", - "Requirement already satisfied: networkx>=2.5 in /usr/local/lib/python3.6/dist-packages (from atomai) (2.5)\n", + "\u001b[?25l Downloading https://files.pythonhosted.org/packages/8c/db/736f6511021257c11260109dd42dcc14410b583b34bee51e949c67af829c/atomai-0.6.2-py3-none-any.whl (108kB)\n", + "\r\u001b[K |███ | 10kB 19.3MB/s eta 0:00:01\r\u001b[K |██████ | 20kB 21.1MB/s eta 0:00:01\r\u001b[K |█████████ | 30kB 10.5MB/s eta 0:00:01\r\u001b[K |████████████ | 40kB 12.4MB/s eta 0:00:01\r\u001b[K |███████████████ | 51kB 11.5MB/s eta 0:00:01\r\u001b[K |██████████████████ | 61kB 12.2MB/s eta 0:00:01\r\u001b[K |█████████████████████ | 71kB 10.9MB/s eta 0:00:01\r\u001b[K |████████████████████████ | 81kB 11.1MB/s eta 0:00:01\r\u001b[K |███████████████████████████ | 92kB 10.9MB/s eta 0:00:01\r\u001b[K |██████████████████████████████ | 102kB 10.9MB/s eta 0:00:01\r\u001b[K |████████████████████████████████| 112kB 10.9MB/s \n", + "\u001b[?25hRequirement already satisfied: opencv-python>=4.1.0 in /usr/local/lib/python3.6/dist-packages (from atomai) (4.1.2.30)\n", + "Requirement already satisfied: scikit-image==0.16.2 in /usr/local/lib/python3.6/dist-packages (from atomai) (0.16.2)\n", "Requirement already satisfied: torch>=1.0.0 in /usr/local/lib/python3.6/dist-packages (from atomai) (1.7.0+cu101)\n", - "Requirement already satisfied: scipy>=1.3.0 in /usr/local/lib/python3.6/dist-packages (from atomai) (1.4.1)\n", + "Requirement already satisfied: numpy>=1.18.5 in /usr/local/lib/python3.6/dist-packages (from atomai) (1.19.5)\n", + "Requirement already satisfied: scikit-learn>=0.22.1 in /usr/local/lib/python3.6/dist-packages (from atomai) (0.22.2.post1)\n", + "Requirement already satisfied: networkx>=2.5 in /usr/local/lib/python3.6/dist-packages (from atomai) (2.5)\n", "Collecting mendeleev>=0.6.0\n", "\u001b[?25l Downloading https://files.pythonhosted.org/packages/f0/75/5863bb298aa1390cb9ecb0548a62b8213ef085273f9d3c73e513b9c36214/mendeleev-0.6.1.tar.gz (193kB)\n", - "\u001b[K |████████████████████████████████| 194kB 19.6MB/s \n", - "\u001b[?25hRequirement already satisfied: scikit-learn>=0.22.1 in /usr/local/lib/python3.6/dist-packages (from atomai) (0.22.2.post1)\n", - "Requirement already satisfied: opencv-python>=4.1.0 in /usr/local/lib/python3.6/dist-packages (from atomai) (4.1.2.30)\n", - "Requirement already satisfied: matplotlib!=3.0.0,>=2.0.0 in /usr/local/lib/python3.6/dist-packages (from scikit-image==0.16.2->atomai) (3.2.2)\n", + "\u001b[K |████████████████████████████████| 194kB 16.5MB/s \n", + "\u001b[?25hRequirement already satisfied: scipy>=1.3.0 in /usr/local/lib/python3.6/dist-packages (from atomai) (1.4.1)\n", "Requirement already satisfied: imageio>=2.3.0 in /usr/local/lib/python3.6/dist-packages (from scikit-image==0.16.2->atomai) (2.4.1)\n", - "Requirement already satisfied: PyWavelets>=0.4.0 in /usr/local/lib/python3.6/dist-packages (from scikit-image==0.16.2->atomai) (1.1.1)\n", "Requirement already satisfied: pillow>=4.3.0 in /usr/local/lib/python3.6/dist-packages (from scikit-image==0.16.2->atomai) (7.0.0)\n", - "Requirement already satisfied: decorator>=4.3.0 in /usr/local/lib/python3.6/dist-packages (from networkx>=2.5->atomai) (4.4.2)\n", + "Requirement already satisfied: PyWavelets>=0.4.0 in /usr/local/lib/python3.6/dist-packages (from scikit-image==0.16.2->atomai) (1.1.1)\n", + "Requirement already satisfied: matplotlib!=3.0.0,>=2.0.0 in /usr/local/lib/python3.6/dist-packages (from scikit-image==0.16.2->atomai) (3.2.2)\n", + "Requirement already satisfied: future in /usr/local/lib/python3.6/dist-packages (from torch>=1.0.0->atomai) (0.16.0)\n", "Requirement already satisfied: dataclasses in /usr/local/lib/python3.6/dist-packages (from torch>=1.0.0->atomai) (0.8)\n", "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.6/dist-packages (from torch>=1.0.0->atomai) (3.7.4.3)\n", - "Requirement already satisfied: future in /usr/local/lib/python3.6/dist-packages (from torch>=1.0.0->atomai) (0.16.0)\n", - "Requirement already satisfied: pandas in /usr/local/lib/python3.6/dist-packages (from mendeleev>=0.6.0->atomai) (1.1.4)\n", - "Requirement already satisfied: sqlalchemy>=1.3.0 in /usr/local/lib/python3.6/dist-packages (from mendeleev>=0.6.0->atomai) (1.3.20)\n", + "Requirement already satisfied: joblib>=0.11 in /usr/local/lib/python3.6/dist-packages (from scikit-learn>=0.22.1->atomai) (1.0.0)\n", + "Requirement already satisfied: decorator>=4.3.0 in /usr/local/lib/python3.6/dist-packages (from networkx>=2.5->atomai) (4.4.2)\n", + "Requirement already satisfied: pandas in /usr/local/lib/python3.6/dist-packages (from mendeleev>=0.6.0->atomai) (1.1.5)\n", + "Requirement already satisfied: sqlalchemy>=1.3.0 in /usr/local/lib/python3.6/dist-packages (from mendeleev>=0.6.0->atomai) (1.3.23)\n", "Collecting colorama\n", " Downloading https://files.pythonhosted.org/packages/44/98/5b86278fbbf250d239ae0ecb724f8572af1c91f4a11edf4d36a206189440/colorama-0.4.4-py2.py3-none-any.whl\n", "Collecting pyfiglet\n", "\u001b[?25l Downloading https://files.pythonhosted.org/packages/33/07/fcfdd7a2872f5b348953de35acce1544dab0c1e8368dca54279b1cde5c15/pyfiglet-0.8.post1-py2.py3-none-any.whl (865kB)\n", - "\u001b[K |████████████████████████████████| 870kB 26.2MB/s \n", - "\u001b[?25hRequirement already satisfied: joblib>=0.11 in /usr/local/lib/python3.6/dist-packages (from scikit-learn>=0.22.1->atomai) (0.17.0)\n", - "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib!=3.0.0,>=2.0.0->scikit-image==0.16.2->atomai) (2.8.1)\n", + "\u001b[K |████████████████████████████████| 870kB 27.3MB/s \n", + "\u001b[?25hRequirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib!=3.0.0,>=2.0.0->scikit-image==0.16.2->atomai) (2.4.7)\n", "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib!=3.0.0,>=2.0.0->scikit-image==0.16.2->atomai) (1.3.1)\n", "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.6/dist-packages (from matplotlib!=3.0.0,>=2.0.0->scikit-image==0.16.2->atomai) (0.10.0)\n", - "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib!=3.0.0,>=2.0.0->scikit-image==0.16.2->atomai) (2.4.7)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib!=3.0.0,>=2.0.0->scikit-image==0.16.2->atomai) (2.8.1)\n", "Requirement already satisfied: pytz>=2017.2 in /usr/local/lib/python3.6/dist-packages (from pandas->mendeleev>=0.6.0->atomai) (2018.9)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.6/dist-packages (from python-dateutil>=2.1->matplotlib!=3.0.0,>=2.0.0->scikit-image==0.16.2->atomai) (1.15.0)\n", + "Requirement already satisfied: six in /usr/local/lib/python3.6/dist-packages (from cycler>=0.10->matplotlib!=3.0.0,>=2.0.0->scikit-image==0.16.2->atomai) (1.15.0)\n", "Building wheels for collected packages: mendeleev\n", " Building wheel for mendeleev (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for mendeleev: filename=mendeleev-0.6.1-py2.py3-none-any.whl size=174964 sha256=ecffbe6210e12dc85d4f1dea7f41634190ddfbfdff993f646ed11f27de3da296\n", + " Created wheel for mendeleev: filename=mendeleev-0.6.1-py2.py3-none-any.whl size=174964 sha256=775a64d9f1d301cd9346133b0b2a9ab26491f9d762cfa20087e8102d4be4aece\n", " Stored in directory: /root/.cache/pip/wheels/fb/28/5d/95e69a718b35dd00169889b0139a692f6c265d399cab3aa097\n", "Successfully built mendeleev\n", "Installing collected packages: colorama, pyfiglet, mendeleev, atomai\n", - "Successfully installed atomai-0.6.0 colorama-0.4.4 mendeleev-0.6.1 pyfiglet-0.8.post1\n" + "Successfully installed atomai-0.6.2 colorama-0.4.4 mendeleev-0.6.1 pyfiglet-0.8.post1\n" ], "name": "stdout" } @@ -160,7 +160,7 @@ "import numpy as np\n", "import matplotlib.pyplot as plt" ], - "execution_count": null, + "execution_count": 2, "outputs": [] }, { @@ -179,36 +179,36 @@ "base_uri": "https://localhost:8080/" }, "id": "0Uc1U6nxhyU9", - "outputId": "773952f4-7a21-47bc-d970-59ac387c065a" + "outputId": "36a62aeb-6814-4ae3-cfc3-bb3238a478c5" }, "source": [ "# Download into VM storage\n", "!wget -O \"graphene_MD_imgs.npy\" https://www.dropbox.com/s/r2cz8jqc9m19gaj/cropped_images_new.npy?dl=1" ], - "execution_count": null, + "execution_count": 3, "outputs": [ { "output_type": "stream", "text": [ - "--2020-12-08 08:24:32-- https://www.dropbox.com/s/r2cz8jqc9m19gaj/cropped_images_new.npy?dl=1\n", - "Resolving www.dropbox.com (www.dropbox.com)... 162.125.65.1, 2620:100:6021:1::a27d:4101\n", - "Connecting to www.dropbox.com (www.dropbox.com)|162.125.65.1|:443... connected.\n", + "--2021-02-05 05:08:53-- https://www.dropbox.com/s/r2cz8jqc9m19gaj/cropped_images_new.npy?dl=1\n", + "Resolving www.dropbox.com (www.dropbox.com)... 162.125.65.18, 2620:100:6021:18::a27d:4112\n", + "Connecting to www.dropbox.com (www.dropbox.com)|162.125.65.18|:443... connected.\n", "HTTP request sent, awaiting response... 301 Moved Permanently\n", "Location: /s/dl/r2cz8jqc9m19gaj/cropped_images_new.npy [following]\n", - "--2020-12-08 08:24:32-- https://www.dropbox.com/s/dl/r2cz8jqc9m19gaj/cropped_images_new.npy\n", + "--2021-02-05 05:08:54-- https://www.dropbox.com/s/dl/r2cz8jqc9m19gaj/cropped_images_new.npy\n", "Reusing existing connection to www.dropbox.com:443.\n", "HTTP request sent, awaiting response... 302 Found\n", - "Location: https://uc28f5dc4a69fea0f591acb41c36.dl.dropboxusercontent.com/cd/0/get/BEprt24d81g5flV-tQ8HEfk-zBJFtmXRKrmsGFcIN6FFe-JyTI8--OOHmHQSx5I8Lzp1jI9PyferX2e7jAFxhK7s927d_8mlcdgtHCYWKliEMRgScBg4kR86f0Q0jgE9vp0/file?dl=1# [following]\n", - "--2020-12-08 08:24:33-- https://uc28f5dc4a69fea0f591acb41c36.dl.dropboxusercontent.com/cd/0/get/BEprt24d81g5flV-tQ8HEfk-zBJFtmXRKrmsGFcIN6FFe-JyTI8--OOHmHQSx5I8Lzp1jI9PyferX2e7jAFxhK7s927d_8mlcdgtHCYWKliEMRgScBg4kR86f0Q0jgE9vp0/file?dl=1\n", - "Resolving uc28f5dc4a69fea0f591acb41c36.dl.dropboxusercontent.com (uc28f5dc4a69fea0f591acb41c36.dl.dropboxusercontent.com)... 162.125.65.15, 2620:100:6021:15::a27d:410f\n", - "Connecting to uc28f5dc4a69fea0f591acb41c36.dl.dropboxusercontent.com (uc28f5dc4a69fea0f591acb41c36.dl.dropboxusercontent.com)|162.125.65.15|:443... connected.\n", + "Location: https://uc14d8d880f887839dcece9cc800.dl.dropboxusercontent.com/cd/0/get/BIViaeVug2NjjHtcKb0SadF1qtEmHCz7DRSuIl6L9wjaC2CAzbc2SuAzXGJvWgHNUgbTQna_D4-LW2HfcMmjcysVM21cY2KNWjNzv5LEBNoQGTOSzWuDkUPV7bESMSNFtDs/file?dl=1# [following]\n", + "--2021-02-05 05:08:54-- https://uc14d8d880f887839dcece9cc800.dl.dropboxusercontent.com/cd/0/get/BIViaeVug2NjjHtcKb0SadF1qtEmHCz7DRSuIl6L9wjaC2CAzbc2SuAzXGJvWgHNUgbTQna_D4-LW2HfcMmjcysVM21cY2KNWjNzv5LEBNoQGTOSzWuDkUPV7bESMSNFtDs/file?dl=1\n", + "Resolving uc14d8d880f887839dcece9cc800.dl.dropboxusercontent.com (uc14d8d880f887839dcece9cc800.dl.dropboxusercontent.com)... 162.125.65.15, 2620:100:6027:15::a27d:480f\n", + "Connecting to uc14d8d880f887839dcece9cc800.dl.dropboxusercontent.com (uc14d8d880f887839dcece9cc800.dl.dropboxusercontent.com)|162.125.65.15|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 3169845376 (3.0G) [application/binary]\n", "Saving to: ‘graphene_MD_imgs.npy’\n", "\n", - "graphene_MD_imgs.np 100%[===================>] 2.95G 29.6MB/s in 1m 46s \n", + "graphene_MD_imgs.np 100%[===================>] 2.95G 21.6MB/s in 2m 26s \n", "\n", - "2020-12-08 08:26:20 (28.4 MB/s) - ‘graphene_MD_imgs.npy’ saved [3169845376/3169845376]\n", + "2021-02-05 05:11:21 (20.7 MB/s) - ‘graphene_MD_imgs.npy’ saved [3169845376/3169845376]\n", "\n" ], "name": "stdout" @@ -231,13 +231,13 @@ "base_uri": "https://localhost:8080/" }, "id": "JGglvEvV_w_4", - "outputId": "63131fa6-c448-460e-8239-f7aadd6ec5bb" + "outputId": "27503b4a-be15-415d-8849-cd00ec109b8a" }, "source": [ "imgdata = np.load(\"graphene_MD_imgs.npy\")[::3] # take ~1/3 of the data\n", "print(imgdata.shape)" ], - "execution_count": null, + "execution_count": 4, "outputs": [ { "output_type": "stream", @@ -267,7 +267,7 @@ "# Add noise to data\n", "imgdata_noisy = imgdata + np.random.normal(scale=8, size=imgdata.shape)" ], - "execution_count": null, + "execution_count": 5, "outputs": [] }, { @@ -284,27 +284,27 @@ "metadata": { "colab": { "base_uri": "https://localhost:8080/", - "height": 354 + "height": 353 }, "id": "UmAt4x2un3WD", - "outputId": "e9c22ca2-80ec-4ffa-9617-5b74bb0b17e5" + "outputId": "e3da6975-ce86-4550-98d9-18fd215e0064" }, "source": [ "k = 15\n", "\n", "_, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))\n", - "ax1.imshow(imgdata[k])\n", - "ax2.imshow(imgdata_noisy[k])\n", - "ax1.set_title(\"Original image\")\n", - "ax2.set_title(\"Corrupted image\")" + "ax1.imshow(imgdata_noisy[k])\n", + "ax2.imshow(imgdata[k])\n", + "ax1.set_title(\"Corrupted image\")\n", + "ax2.set_title(\"Original image\")" ], - "execution_count": null, + "execution_count": 6, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ - "Text(0.5, 1.0, 'Corrupted image')" + "Text(0.5, 1.0, 'Original image')" ] }, "metadata": { @@ -315,7 +315,7 @@ { "output_type": "display_data", "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -346,7 +346,7 @@ " imgdata_test, imgdata_noisy_test) = aoi.utils.data_split(\n", " imgdata, imgdata_noisy, format_out=\"torch_float\", channel=\"first\")" ], - "execution_count": null, + "execution_count": 7, "outputs": [] }, { @@ -386,7 +386,7 @@ "\n", "torch_DAE = torch.nn.Sequential(torch_encoder, torch_decoder)" ], - "execution_count": null, + "execution_count": 8, "outputs": [] }, { @@ -407,7 +407,7 @@ "trainer = aoi.trainers.BaseTrainer()\n", "trainer.set_model(torch_DAE)" ], - "execution_count": null, + "execution_count": 9, "outputs": [] }, { @@ -435,7 +435,7 @@ " loss=\"mse\", training_cycles=500, swa=True # training parameters\n", ")" ], - "execution_count": null, + "execution_count": 10, "outputs": [] }, { @@ -444,7 +444,7 @@ "id": "r58jPXJGiYY6" }, "source": [ - "Finally, we train a model:" + "Finally, we train our model:" ] }, { @@ -452,25 +452,25 @@ "metadata": { "colab": { "base_uri": "https://localhost:8080/", - "height": 572 + "height": 561 }, "id": "LKZE6o-tGEqP", - "outputId": "982944ea-0644-4ecb-9a48-eb206b8b6890" + "outputId": "c762e778-0ebf-4f2b-8181-18d587fa2845" }, "source": [ "trained_model = trainer.run()" ], - "execution_count": null, + "execution_count": 11, "outputs": [ { "output_type": "stream", "text": [ - "Epoch 1/500 ... Training loss: 68.9254 ... Test loss: 65.0157 ... GPU memory usage: 2787/16130\n", - "Epoch 100/500 ... Training loss: 2.1962 ... Test loss: 2.3446 ... GPU memory usage: 2787/16130\n", - "Epoch 200/500 ... Training loss: 1.3163 ... Test loss: 1.489 ... GPU memory usage: 2787/16130\n", - "Epoch 300/500 ... Training loss: 0.9035 ... Test loss: 1.3594 ... GPU memory usage: 2787/16130\n", - "Epoch 400/500 ... Training loss: 0.8195 ... Test loss: 0.7596 ... GPU memory usage: 2787/16130\n", - "Epoch 500/500 ... Training loss: 1.0444 ... Test loss: 0.7401 ... GPU memory usage: 2787/16130\n", + "Epoch 1/500 ... Training loss: 68.9254 ... Test loss: 65.0157 ... GPU memory usage: 3779/16130\n", + "Epoch 100/500 ... Training loss: 2.1962 ... Test loss: 2.3446 ... GPU memory usage: 3779/16130\n", + "Epoch 200/500 ... Training loss: 1.3163 ... Test loss: 1.489 ... GPU memory usage: 3779/16130\n", + "Epoch 300/500 ... Training loss: 0.9035 ... Test loss: 1.3594 ... GPU memory usage: 3779/16130\n", + "Epoch 400/500 ... Training loss: 0.8195 ... Test loss: 0.7596 ... GPU memory usage: 3779/16130\n", + "Epoch 500/500 ... Training loss: 1.0444 ... Test loss: 0.7401 ... GPU memory usage: 3779/16130\n", "Model (final state) evaluation loss: 0.75\n", "Performing stochastic weights averaging...\n", "Model (final state) evaluation loss: 0.6919\n", @@ -511,7 +511,7 @@ "p = aoi.predictors.BasePredictor(trained_model, use_gpu=True)\n", "prediction = p.predict(imgdata_noisy_test)" ], - "execution_count": null, + "execution_count": 12, "outputs": [] }, { @@ -522,7 +522,7 @@ "height": 279 }, "id": "og9dgQUmKWC3", - "outputId": "720f65b3-2648-4252-df59-1f78029ee895" + "outputId": "d4fd3d17-5f0c-41b4-ffaf-caf08230e47b" }, "source": [ "k = 50\n", @@ -535,7 +535,7 @@ "ax2.set_title(\"Cleaned data\")\n", "ax3.set_title(\"Difference\")" ], - "execution_count": null, + "execution_count": 13, "outputs": [ { "output_type": "execute_result", @@ -590,7 +590,7 @@ "height": 1000 }, "id": "fn4a7mlAPbrf", - "outputId": "52df7d4b-9c22-40ee-ed52-c2567f6f78fa" + "outputId": "184c83bd-1c60-40b6-e244-a756d8d5863a" }, "source": [ "img = imgdata_test[k:k+1]\n", @@ -604,7 +604,7 @@ " ax2.set_title(\"Cleaned data\")\n", " plt.show()" ], - "execution_count": null, + "execution_count": 14, "outputs": [ { "output_type": "display_data", @@ -884,36 +884,36 @@ "base_uri": "https://localhost:8080/" }, "id": "4A7TDnjzb2mz", - "outputId": "304a2bcc-6b8a-4ed8-9583-06acf5cf0c5c" + "outputId": "0deb016a-86f4-4b96-fa2b-88f0c51eecb1" }, "source": [ "# download data\n", "!wget -O \"graphene_exp.npy\" https://www.dropbox.com/s/33uo35z4siiy2y4/Gr_SiCr.npy?dl=1" ], - "execution_count": null, + "execution_count": 15, "outputs": [ { "output_type": "stream", "text": [ - "--2020-12-08 08:27:49-- https://www.dropbox.com/s/33uo35z4siiy2y4/Gr_SiCr.npy?dl=1\n", - "Resolving www.dropbox.com (www.dropbox.com)... 162.125.65.1, 2620:100:6021:1::a27d:4101\n", - "Connecting to www.dropbox.com (www.dropbox.com)|162.125.65.1|:443... connected.\n", + "--2021-02-05 05:13:40-- https://www.dropbox.com/s/33uo35z4siiy2y4/Gr_SiCr.npy?dl=1\n", + "Resolving www.dropbox.com (www.dropbox.com)... 162.125.65.18, 2620:100:6022:18::a27d:4212\n", + "Connecting to www.dropbox.com (www.dropbox.com)|162.125.65.18|:443... connected.\n", "HTTP request sent, awaiting response... 301 Moved Permanently\n", "Location: /s/dl/33uo35z4siiy2y4/Gr_SiCr.npy [following]\n", - "--2020-12-08 08:27:49-- https://www.dropbox.com/s/dl/33uo35z4siiy2y4/Gr_SiCr.npy\n", + "--2021-02-05 05:13:40-- https://www.dropbox.com/s/dl/33uo35z4siiy2y4/Gr_SiCr.npy\n", "Reusing existing connection to www.dropbox.com:443.\n", "HTTP request sent, awaiting response... 302 Found\n", - "Location: https://uc73f617ed330734b75c84a19c0d.dl.dropboxusercontent.com/cd/0/get/BEowLmAAf42WsBLVVv52cemY6sZs8nAmRR7wnnh1Mzh2Hhue9QIg2H2f6IsxQWp5Ho2AzonXXX7AFiHgs-DhFIayATM9AuAtr_P2_seGjzaQg-Iy8RrhhnPqzC1ugiIaCxU/file?dl=1# [following]\n", - "--2020-12-08 08:27:49-- https://uc73f617ed330734b75c84a19c0d.dl.dropboxusercontent.com/cd/0/get/BEowLmAAf42WsBLVVv52cemY6sZs8nAmRR7wnnh1Mzh2Hhue9QIg2H2f6IsxQWp5Ho2AzonXXX7AFiHgs-DhFIayATM9AuAtr_P2_seGjzaQg-Iy8RrhhnPqzC1ugiIaCxU/file?dl=1\n", - "Resolving uc73f617ed330734b75c84a19c0d.dl.dropboxusercontent.com (uc73f617ed330734b75c84a19c0d.dl.dropboxusercontent.com)... 162.125.65.15, 2620:100:6021:15::a27d:410f\n", - "Connecting to uc73f617ed330734b75c84a19c0d.dl.dropboxusercontent.com (uc73f617ed330734b75c84a19c0d.dl.dropboxusercontent.com)|162.125.65.15|:443... connected.\n", + "Location: https://uc2b0c6d4ef46f505efed213d457.dl.dropboxusercontent.com/cd/0/get/BIWsTveC-w6rG8ToFN2xh6TiJAktoLybTDfEng2MeS7wCqmWb1NODsq_CLpS54a7Q7SzP-n6AJTZ-6ArxhEitIDH6c8w6p4tGxWxUBY9LRrSwoX-soAksVWDg5LhKGRZTLM/file?dl=1# [following]\n", + "--2021-02-05 05:13:41-- https://uc2b0c6d4ef46f505efed213d457.dl.dropboxusercontent.com/cd/0/get/BIWsTveC-w6rG8ToFN2xh6TiJAktoLybTDfEng2MeS7wCqmWb1NODsq_CLpS54a7Q7SzP-n6AJTZ-6ArxhEitIDH6c8w6p4tGxWxUBY9LRrSwoX-soAksVWDg5LhKGRZTLM/file?dl=1\n", + "Resolving uc2b0c6d4ef46f505efed213d457.dl.dropboxusercontent.com (uc2b0c6d4ef46f505efed213d457.dl.dropboxusercontent.com)... 162.125.65.15, 2620:100:6027:15::a27d:480f\n", + "Connecting to uc2b0c6d4ef46f505efed213d457.dl.dropboxusercontent.com (uc2b0c6d4ef46f505efed213d457.dl.dropboxusercontent.com)|162.125.65.15|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 4194432 (4.0M) [application/binary]\n", "Saving to: ‘graphene_exp.npy’\n", "\n", - "graphene_exp.npy 100%[===================>] 4.00M 14.8MB/s in 0.3s \n", + "graphene_exp.npy 100%[===================>] 4.00M 5.59MB/s in 0.7s \n", "\n", - "2020-12-08 08:27:50 (14.8 MB/s) - ‘graphene_exp.npy’ saved [4194432/4194432]\n", + "2021-02-05 05:13:43 (5.59 MB/s) - ‘graphene_exp.npy’ saved [4194432/4194432]\n", "\n" ], "name": "stdout" @@ -929,7 +929,7 @@ "expdata = np.load(\"graphene_exp.npy\")\n", "expdata = expdata * 60 # scale it to the range of pixel values used in training data" ], - "execution_count": null, + "execution_count": 16, "outputs": [] }, { @@ -940,7 +940,7 @@ "height": 559 }, "id": "EjkeUPfSb2m1", - "outputId": "6acc12b7-9f52-4f62-8cab-f2881c1ec2e2" + "outputId": "1355b7d0-e23e-4dbe-f0f8-394410cf2c7e" }, "source": [ "pred = p.predict(expdata[None, None])\n", @@ -949,13 +949,13 @@ "ax1.imshow(expdata)\n", "ax2.imshow(pred.squeeze())" ], - "execution_count": null, + "execution_count": 17, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ - "" + "" ] }, "metadata": { diff --git a/requirements.txt b/requirements.txt index bd89e8d0..e0762321 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,10 +1,8 @@ setuptools>=41.0.1 flake8>=3.7.9 matplotlib>=3.1.1 -pydot>=1.3.0 -torchviz>=0.0.1 +torchvision>=0.2.1 gdown>=3.8.1 -jupyterlab>=1.0.1 torch>=1.0.0 numpy>=1.16.4 scipy>=1.3.0 @@ -12,3 +10,4 @@ scikit-learn>=0.22.1 scikit-image==0.16.2 opencv-python>=4.1.0 networkx>=2.5 +mendeleev>=0.6.0 diff --git a/setup.py b/setup.py index e7d87afe..fc66af4f 100644 --- a/setup.py +++ b/setup.py @@ -28,12 +28,14 @@ install_requires=[ 'torch>=1.0.0', 'numpy>=1.18.5', + 'matplotlib>=3.2,<3.4', 'scipy>=1.3.0', 'scikit-learn>=0.22.1', 'scikit-image==0.16.2', 'opencv-python>=4.1.0', 'networkx>=2.5', - 'mendeleev>=0.6.0' + 'mendeleev>=0.6.0', + 'torchvision>=0.2.1' ], classifiers=['Programming Language :: Python', 'Development Status :: 3 - Alpha', diff --git a/test/models/test_loaders.py b/test/models/test_loaders.py index 44abc366..4f120a7c 100644 --- a/test/models/test_loaders.py +++ b/test/models/test_loaders.py @@ -1,11 +1,12 @@ import sys import pytest import numpy as np -from numpy.testing import assert_array_equal +from numpy.testing import assert_array_equal, assert_equal, assert_ sys.path.append("../../../") -from atomai.models import Segmentor, ImSpec, VAE, rVAE, load_model, load_ensemble +from atomai.models import (Segmentor, ImSpec, VAE, rVAE, jVAE, + jrVAE, load_model, load_ensemble) from atomai.trainers import EnsembleTrainer @@ -35,6 +36,11 @@ def gen_spectra(): X_ = np.random.random(size=(5, 1, 16)) return X, X_ +def compare_optimizers(opt1, opt2): + for group_param1, group_param2 in zip(opt1.param_groups, opt2.param_groups): + for param1, param2 in zip(group_param1["params"], group_param1["params"]): + for p1, p2 in zip(param1, param2): + assert_array_equal(p1.detach().cpu().numpy(), p2.detach().cpu().numpy()) @pytest.mark.parametrize("model", ["Unet", "dilnet", "SegResNet", "ResHedNet"]) def test_io_segmentor(model): @@ -47,6 +53,19 @@ def test_io_segmentor(model): assert_array_equal(p1.detach().cpu().numpy(), p2.detach().cpu().numpy()) +@pytest.mark.parametrize("model", ["Unet", "dilnet", "SegResNet", "ResHedNet"]) +def test_saved_optimizer_segmentor(model): + X, X_test = gen_image_data() + y, y_test = gen_image_labels() + segmodel = Segmentor(model, nb_classes=3) + segmodel.fit(X, y, X_test, y_test, training_cycles=4, batch_size=2, + filename="segmodel") + opt1 = segmodel.optimizer + loaded_model = load_model("segmodel_metadict_final.tar") + opt2 = loaded_model.optimizer + compare_optimizers(opt1, opt2) + + def test_io_imspec(): X, X_test = gen_image_data() y, y_test = gen_spectra() @@ -57,7 +76,18 @@ def test_io_imspec(): assert_array_equal(p1.detach().cpu().numpy(), p2.detach().cpu().numpy()) -@pytest.mark.parametrize("model", [VAE, rVAE]) +def test_saved_optimizer_imspec(): + X, X_test = gen_image_data() + y, y_test = gen_spectra() + i2s_model = ImSpec((8, 8), (16,)) + i2s_model.fit(X, y, X_test, y_test, training_cycles=4, batch_size=2) + opt1 = i2s_model.optimizer + loaded_model = load_model("model_metadict_final.tar") + opt2 = loaded_model.optimizer + compare_optimizers(opt1, opt2) + + +@pytest.mark.parametrize("model", [VAE, rVAE, jVAE, jrVAE]) def test_io_VAE(model): X, _ = gen_image_data() X = X[:, 0, ...] @@ -72,6 +102,42 @@ def test_io_VAE(model): assert_array_equal(p1.detach().cpu().numpy(), p2.detach().cpu().numpy()) +@pytest.mark.parametrize("model", [VAE, rVAE, jVAE, jrVAE]) +def test_saved_optimizer_VAE(model): + X, _ = gen_image_data() + X = X[:, 0, ...] + vae_model = model((8, 8)) + vae_model.fit(X, training_cycles=4, batch_size=2, filename="vae_metadict") + opt1 = vae_model.optim + loaded_model = load_model("vae_metadict.tar") + opt2 = loaded_model.optim + compare_optimizers(opt1, opt2) + +@pytest.mark.parametrize("model", [jVAE, jrVAE]) +def test_saved_iter_jVAE(model): + X, _ = gen_image_data() + X = X[:, 0, ...] + vae_model = model((8, 8)) + vae_model.fit(X, training_cycles=4, batch_size=2, filename="jvae_metadict") + num_iter = vae_model.kdict_["num_iter"] + loaded_model = load_model("jvae_metadict.tar") + assert_equal(num_iter, loaded_model.kdict_["num_iter"]) + + +@pytest.mark.parametrize("model", [VAE, rVAE, jVAE, jrVAE]) +def test_resume_training(model): + X, _ = gen_image_data() + X = X[:, 0, ...] + vae_model = model((8, 8)) + vae_model.fit(X, training_cycles=4, batch_size=2, filename="vae_metadict") + loss0 = abs(vae_model.loss_history["train_loss"][0]) + loaded_model = load_model("vae_metadict.tar") + loaded_model.fit(X, training_cycles=4, batch_size=2, filename="vae_metadict") + loss1 = abs(loaded_model.loss_history["train_loss"][0]) + assert_(not np.isnan(loss1)) + assert_(loss1 < loss0) + + @pytest.mark.parametrize("model", ["Unet", "dilnet", "SegResNet", "ResHedNet"]) def test_io_ensemble_seg(model): X, X_test = gen_image_data() diff --git a/test/models/test_vae.py b/test/models/test_vae.py new file mode 100644 index 00000000..533ae8e7 --- /dev/null +++ b/test/models/test_vae.py @@ -0,0 +1,114 @@ +import sys + +import numpy as np +import torch +import pytest +from numpy.testing import assert_equal, assert_, assert_allclose + +sys.path.append("../../../") + +from atomai.models import VAE, rVAE, jVAE, jrVAE + + +def gen_image_data(torch_format=True): + """ + Dummy image with random pixels + """ + X = np.random.random(size=(100, 28, 28)) + if torch_format: + X = torch.from_numpy(X).float() + return X + + +@pytest.mark.parametrize("latent_dim, encoded_dim", [(2, 2), (10, 10)]) +def test_encoding_VAE(latent_dim, encoded_dim): + input_dim = (28, 28) + data = gen_image_data() + v = VAE(input_dim, latent_dim, numhidden_encoder=16, numhidden_decoder=16) + v.fit(data, training_cycles=2) + z = v.encode(data) + assert_equal(len(z), 2) + assert_equal(z[0].shape[-1], encoded_dim) + assert_equal(z[1].shape[-1], encoded_dim) + + +@pytest.mark.parametrize( + "translation, latent_dim, encoded_dim", + [(False, 2, 3), (False, 10, 11), (True, 2, 5), (True, 10, 13)]) +def test_encoding_rVAE(translation, latent_dim, encoded_dim): + input_dim = (28, 28) + data = gen_image_data() + v = rVAE(input_dim, latent_dim, translation=translation, + numhidden_encoder=16, numhidden_decoder=16) + v.fit(data, training_cycles=2) + z = v.encode(data) + assert_equal(len(z), 2) + assert_equal(z[0].shape[-1], encoded_dim) + assert_equal(z[1].shape[-1], encoded_dim) + + +@pytest.mark.parametrize( + "translation, latent_cont_dim, encoded_dim_cont", + [(False, 2, 3), (False, 10, 11), (True, 2, 5), (True, 10, 13)]) +def test_encoding_jrVAE(translation, latent_cont_dim, encoded_dim_cont): + input_dim = (28, 28) + data = gen_image_data() + v = jrVAE( + input_dim, latent_cont_dim, discrete_dim=[5], + translation=translation, numhidden_encoder=16, numhidden_decoder=16) + v.fit(data, training_cycles=2) + z = v.encode(data) + assert_equal(len(z), 3) + assert_equal(z[0].shape[-1], encoded_dim_cont) + assert_equal(z[1].shape[-1], encoded_dim_cont) + assert_equal(z[2].shape[-1], 5) + + +@pytest.mark.parametrize("conv_encoder", [True, False]) +@pytest.mark.parametrize("conv_decoder", [True, False]) +@pytest.mark.parametrize("latent_dim", [2, 10]) +def test_decoding_VAE(conv_encoder, conv_decoder, latent_dim): + input_dim = (28, 28) + data = gen_image_data() + v = VAE(input_dim, latent_dim, + conv_encoder=conv_encoder, + conv_decoder=conv_decoder, + numhidden_encoder=16, + numhidden_decoder=16) + v.fit(data, training_cycles=2) + z_sample = np.zeros((latent_dim))[None] + decoded = v.decode(z_sample) + assert_equal(decoded.shape[1:], input_dim) + assert_(np.sum(decoded) != 0) + + +@pytest.mark.parametrize("conv_encoder", [True, False]) +@pytest.mark.parametrize("conv_decoder", [True, False]) +@pytest.mark.parametrize("translation", [True, False]) +@pytest.mark.parametrize("latent_dim", [2, 10]) +def test_decoding_rVAE(conv_encoder, conv_decoder, translation, latent_dim): + input_dim = (28, 28) + data = gen_image_data() + v = rVAE(input_dim, latent_dim, translation=translation, + numhidden_encoder=16, numhidden_decoder=16) + v.fit(data, training_cycles=2) + z_sample = np.zeros((latent_dim))[None] + decoded = v.decode(z_sample) + assert_equal(decoded.shape[1:], input_dim) + assert_(np.sum(decoded) != 0) + + +@pytest.mark.parametrize("conv_encoder", [True, False]) +@pytest.mark.parametrize("conv_decoder", [True, False]) +@pytest.mark.parametrize("translation", [True, False]) +@pytest.mark.parametrize("latent_dim", [2, 10]) +def test_decoding_jrVAE(conv_encoder, conv_decoder, translation, latent_dim): + input_dim = (28, 28) + data = gen_image_data() + v = jrVAE(input_dim, latent_dim, discrete_dim=[5], translation=translation, + numhidden_encoder=16, numhidden_decoder=16) + v.fit(data, training_cycles=2) + z_sample = np.zeros((latent_dim+5))[None] + decoded = v.decode(z_sample) + assert_equal(decoded.shape[1:], input_dim) + assert_(np.sum(decoded) != 0) \ No newline at end of file diff --git a/test/trainers/test_vitrainer.py b/test/trainers/test_vitrainer.py new file mode 100644 index 00000000..6cbe18e6 --- /dev/null +++ b/test/trainers/test_vitrainer.py @@ -0,0 +1,114 @@ +import sys + +import numpy as np +import torch +import pytest +from numpy.testing import assert_equal, assert_, assert_allclose + +sys.path.append("../../../") + +from atomai.trainers import viBaseTrainer +from atomai.nets import fcEncoderNet, fcDecoderNet, convEncoderNet, convDecoderNet +from atomai.losses_metrics import vae_loss + + +def gen_image_data(torch_format=True): + """ + Dummy image with random pixels + """ + X = np.random.random(size=(100, 28, 28)) + if torch_format: + X = torch.from_numpy(X).float() + return X + + +class simple_vae(viBaseTrainer): + + def __init__(self, in_dim): + super(simple_vae, self).__init__() + self.in_dim = in_dim + + def elbo_fn(self, x, x_reconstr, *args): + return vae_loss("mse", self.in_dim, x, x_reconstr, *args) + + def forward_compute_elbo(self, x, y=None, mode="train"): + if mode == "eval": + with torch.no_grad(): + z_mean, z_logsd = self.encoder_net(x) + else: + z_mean, z_logsd = self.encoder_net(x) + z_sd = torch.exp(z_logsd) + z = self.reparameterize(z_mean, z_sd) + if mode == "eval": + with torch.no_grad(): + x_reconstr = self.decoder_net(z) + else: + x_reconstr = self.decoder_net(z) + return self.elbo_fn(x, x_reconstr, z_mean, z_logsd) + + +@pytest.mark.parametrize("encoder", [fcEncoderNet, convEncoderNet]) +@pytest.mark.parametrize("decoder", [fcDecoderNet, convDecoderNet]) +def test_set_nets(encoder, decoder): + in_dim = (28, 28) + v = viBaseTrainer() + encoder_ = encoder(in_dim, 2) + decoder_ = decoder(in_dim, 2) + v.set_model(encoder_, decoder_) + assert_(hasattr(v.encoder_net, "state_dict")) + assert_(hasattr(v.decoder_net, "state_dict")) + + +@pytest.mark.parametrize("encoder", [fcEncoderNet, convEncoderNet]) +@pytest.mark.parametrize("decoder", [fcDecoderNet, convDecoderNet]) +def test_set_nets_separately(encoder, decoder): + in_dim = (28, 28) + v = viBaseTrainer() + v.set_encoder(encoder(in_dim, 2)) + v.set_decoder(decoder(in_dim, 2)) + assert_(hasattr(v.encoder_net, "state_dict")) + assert_(hasattr(v.decoder_net, "state_dict")) + + +@pytest.mark.parametrize("torch_format", [True, False]) +def test_set_data(torch_format): + data = gen_image_data(torch_format) + v = viBaseTrainer() + v.set_data(data) + assert_(isinstance(v.train_iterator, torch.utils.data.DataLoader)) + + +def test_reparametrize(): + input_dim = (28, 28) + data = gen_image_data() + v = viBaseTrainer() + v.set_encoder(fcEncoderNet(input_dim, 2)) + v.set_data(data) + z_mu, z_sd = v.encoder_net(data) + z = v.reparameterize(z_mu, z_sd) + assert_(np.any(np.not_equal(z.detach().cpu().numpy(), z_mu.detach().cpu().numpy()))) + assert_equal(z.detach().cpu().numpy().shape, (100, 2)) + + +def test_custom_optimizer(): + in_dim = (28, 28) + data = gen_image_data() + custom_optimizer1 = lambda x: torch.optim.Adam(x, lr=1e-2) + custom_optimizer2 = lambda x: torch.optim.Adam(x, lr=1e-6) + vae = simple_vae(in_dim) + vae.set_encoder(fcEncoderNet(in_dim, 2)) + vae.set_decoder(fcDecoderNet(in_dim, 2)) + vae.compile_trainer((data,), optimizer=custom_optimizer1) + for _ in range(4): + vae.loss_history["train_loss"].append(vae.train_epoch()) + delta1 = abs(vae.loss_history["train_loss"][-1] + - vae.loss_history["train_loss"][0]) + vae._reset_weights() + vae._reset_training_history() + vae._delete_optimizer() + vae.compile_trainer((data,), optimizer=custom_optimizer2) + for _ in range(4): + vae.loss_history["train_loss"].append(vae.train_epoch()) + delta2 = abs(vae.loss_history["train_loss"][-1] + - vae.loss_history["train_loss"][0]) + assert_(delta1 > 2 * delta2)