repo stringlengths 1 99 | file stringlengths 13 215 | code stringlengths 12 59.2M | file_length int64 12 59.2M | avg_line_length float64 3.82 1.48M | max_line_length int64 12 2.51M | extension_type stringclasses 1
value |
|---|---|---|---|---|---|---|
TuRBO | TuRBO-master/setup.py | from setuptools import setup, find_packages
setup(
name="turbo",
version="0.0.1",
packages=find_packages(),
install_requires=["numpy>=1.17.3", "torch>=1.3.0", "gpytorch>=0.3.6"],
)
| 198 | 21.111111 | 74 | py |
TuRBO | TuRBO-master/turbo/turbo_m.py | ###############################################################################
# Copyright (c) 2019 Uber Technologies, Inc. #
# #
# Licensed under the Uber Non-Commercial License (the "License"); #
# you may not use this file except in compliance with the License. #
# You may obtain a copy of the License at the root directory of this project. #
# #
# See the License for the specific language governing permissions and #
# limitations under the License. #
###############################################################################
import math
import sys
from copy import deepcopy
import gpytorch
import numpy as np
import torch
from .gp import train_gp
from .turbo_1 import Turbo1
from .utils import from_unit_cube, latin_hypercube, to_unit_cube
class TurboM(Turbo1):
"""The TuRBO-m algorithm.
Parameters
----------
f : function handle
lb : Lower variable bounds, numpy.array, shape (d,).
ub : Upper variable bounds, numpy.array, shape (d,).
n_init : Number of initial points *FOR EACH TRUST REGION* (2*dim is recommended), int.
max_evals : Total evaluation budget, int.
n_trust_regions : Number of trust regions
batch_size : Number of points in each batch, int.
verbose : If you want to print information about the optimization progress, bool.
use_ard : If you want to use ARD for the GP kernel.
max_cholesky_size : Largest number of training points where we use Cholesky, int
n_training_steps : Number of training steps for learning the GP hypers, int
min_cuda : We use float64 on the CPU if we have this or fewer datapoints
device : Device to use for GP fitting ("cpu" or "cuda")
dtype : Dtype to use for GP fitting ("float32" or "float64")
Example usage:
turbo5 = TurboM(f=f, lb=lb, ub=ub, n_init=n_init, max_evals=max_evals, n_trust_regions=5)
turbo5.optimize() # Run optimization
X, fX = turbo5.X, turbo5.fX # Evaluated points
"""
def __init__(
self,
f,
lb,
ub,
n_init,
max_evals,
n_trust_regions,
batch_size=1,
verbose=True,
use_ard=True,
max_cholesky_size=2000,
n_training_steps=50,
min_cuda=1024,
device="cpu",
dtype="float64",
):
self.n_trust_regions = n_trust_regions
super().__init__(
f=f,
lb=lb,
ub=ub,
n_init=n_init,
max_evals=max_evals,
batch_size=batch_size,
verbose=verbose,
use_ard=use_ard,
max_cholesky_size=max_cholesky_size,
n_training_steps=n_training_steps,
min_cuda=min_cuda,
device=device,
dtype=dtype,
)
self.succtol = 3
self.failtol = max(5, self.dim)
# Very basic input checks
assert n_trust_regions > 1 and isinstance(max_evals, int)
assert max_evals > n_trust_regions * n_init, "Not enough trust regions to do initial evaluations"
assert max_evals > batch_size, "Not enough evaluations to do a single batch"
# Remember the hypers for trust regions we don't sample from
self.hypers = [{} for _ in range(self.n_trust_regions)]
# Initialize parameters
self._restart()
def _restart(self):
self._idx = np.zeros((0, 1), dtype=int) # Track what trust region proposed what using an index vector
self.failcount = np.zeros(self.n_trust_regions, dtype=int)
self.succcount = np.zeros(self.n_trust_regions, dtype=int)
self.length = self.length_init * np.ones(self.n_trust_regions)
def _adjust_length(self, fX_next, i):
assert i >= 0 and i <= self.n_trust_regions - 1
fX_min = self.fX[self._idx[:, 0] == i, 0].min() # Target value
if fX_next.min() < fX_min - 1e-3 * math.fabs(fX_min):
self.succcount[i] += 1
self.failcount[i] = 0
else:
self.succcount[i] = 0
self.failcount[i] += len(fX_next) # NOTE: Add size of the batch for this TR
if self.succcount[i] == self.succtol: # Expand trust region
self.length[i] = min([2.0 * self.length[i], self.length_max])
self.succcount[i] = 0
elif self.failcount[i] >= self.failtol: # Shrink trust region (we may have exceeded the failtol)
self.length[i] /= 2.0
self.failcount[i] = 0
def _select_candidates(self, X_cand, y_cand):
"""Select candidates from samples from all trust regions."""
assert X_cand.shape == (self.n_trust_regions, self.n_cand, self.dim)
assert y_cand.shape == (self.n_trust_regions, self.n_cand, self.batch_size)
assert X_cand.min() >= 0.0 and X_cand.max() <= 1.0 and np.all(np.isfinite(y_cand))
X_next = np.zeros((self.batch_size, self.dim))
idx_next = np.zeros((self.batch_size, 1), dtype=int)
for k in range(self.batch_size):
i, j = np.unravel_index(np.argmin(y_cand[:, :, k]), (self.n_trust_regions, self.n_cand))
assert y_cand[:, :, k].min() == y_cand[i, j, k]
X_next[k, :] = deepcopy(X_cand[i, j, :])
idx_next[k, 0] = i
assert np.isfinite(y_cand[i, j, k]) # Just to make sure we never select nan or inf
# Make sure we never pick this point again
y_cand[i, j, :] = np.inf
return X_next, idx_next
def optimize(self):
"""Run the full optimization process."""
# Create initial points for each TR
for i in range(self.n_trust_regions):
X_init = latin_hypercube(self.n_init, self.dim)
X_init = from_unit_cube(X_init, self.lb, self.ub)
fX_init = np.array([[self.f(x)] for x in X_init])
# Update budget and set as initial data for this TR
self.X = np.vstack((self.X, X_init))
self.fX = np.vstack((self.fX, fX_init))
self._idx = np.vstack((self._idx, i * np.ones((self.n_init, 1), dtype=int)))
self.n_evals += self.n_init
if self.verbose:
fbest = fX_init.min()
print(f"TR-{i} starting from: {fbest:.4}")
sys.stdout.flush()
# Thompson sample to get next suggestions
while self.n_evals < self.max_evals:
# Generate candidates from each TR
X_cand = np.zeros((self.n_trust_regions, self.n_cand, self.dim))
y_cand = np.inf * np.ones((self.n_trust_regions, self.n_cand, self.batch_size))
for i in range(self.n_trust_regions):
idx = np.where(self._idx == i)[0] # Extract all "active" indices
# Get the points, values the active values
X = deepcopy(self.X[idx, :])
X = to_unit_cube(X, self.lb, self.ub)
# Get the values from the standardized data
fX = deepcopy(self.fX[idx, 0].ravel())
# Don't retrain the model if the training data hasn't changed
n_training_steps = 0 if self.hypers[i] else self.n_training_steps
# Create new candidates
X_cand[i, :, :], y_cand[i, :, :], self.hypers[i] = self._create_candidates(
X, fX, length=self.length[i], n_training_steps=n_training_steps, hypers=self.hypers[i]
)
# Select the next candidates
X_next, idx_next = self._select_candidates(X_cand, y_cand)
assert X_next.min() >= 0.0 and X_next.max() <= 1.0
# Undo the warping
X_next = from_unit_cube(X_next, self.lb, self.ub)
# Evaluate batch
fX_next = np.array([[self.f(x)] for x in X_next])
# Update trust regions
for i in range(self.n_trust_regions):
idx_i = np.where(idx_next == i)[0]
if len(idx_i) > 0:
self.hypers[i] = {} # Remove model hypers
fX_i = fX_next[idx_i]
if self.verbose and fX_i.min() < self.fX.min() - 1e-3 * math.fabs(self.fX.min()):
n_evals, fbest = self.n_evals, fX_i.min()
print(f"{n_evals}) New best @ TR-{i}: {fbest:.4}")
sys.stdout.flush()
self._adjust_length(fX_i, i)
# Update budget and append data
self.n_evals += self.batch_size
self.X = np.vstack((self.X, deepcopy(X_next)))
self.fX = np.vstack((self.fX, deepcopy(fX_next)))
self._idx = np.vstack((self._idx, deepcopy(idx_next)))
# Check if any TR needs to be restarted
for i in range(self.n_trust_regions):
if self.length[i] < self.length_min: # Restart trust region if converged
idx_i = self._idx[:, 0] == i
if self.verbose:
n_evals, fbest = self.n_evals, self.fX[idx_i, 0].min()
print(f"{n_evals}) TR-{i} converged to: : {fbest:.4}")
sys.stdout.flush()
# Reset length and counters, remove old data from trust region
self.length[i] = self.length_init
self.succcount[i] = 0
self.failcount[i] = 0
self._idx[idx_i, 0] = -1 # Remove points from trust region
self.hypers[i] = {} # Remove model hypers
# Create a new initial design
X_init = latin_hypercube(self.n_init, self.dim)
X_init = from_unit_cube(X_init, self.lb, self.ub)
fX_init = np.array([[self.f(x)] for x in X_init])
# Print progress
if self.verbose:
n_evals, fbest = self.n_evals, fX_init.min()
print(f"{n_evals}) TR-{i} is restarting from: : {fbest:.4}")
sys.stdout.flush()
# Append data to local history
self.X = np.vstack((self.X, X_init))
self.fX = np.vstack((self.fX, fX_init))
self._idx = np.vstack((self._idx, i * np.ones((self.n_init, 1), dtype=int)))
self.n_evals += self.n_init
| 10,583 | 41.677419 | 110 | py |
TuRBO | TuRBO-master/turbo/gp.py | ###############################################################################
# Copyright (c) 2019 Uber Technologies, Inc. #
# #
# Licensed under the Uber Non-Commercial License (the "License"); #
# you may not use this file except in compliance with the License. #
# You may obtain a copy of the License at the root directory of this project. #
# #
# See the License for the specific language governing permissions and #
# limitations under the License. #
###############################################################################
import math
import gpytorch
import numpy as np
import torch
from gpytorch.constraints.constraints import Interval
from gpytorch.distributions import MultivariateNormal
from gpytorch.kernels import MaternKernel, ScaleKernel
from gpytorch.likelihoods import GaussianLikelihood
from gpytorch.means import ConstantMean
from gpytorch.mlls import ExactMarginalLogLikelihood
from gpytorch.models import ExactGP
# GP Model
class GP(ExactGP):
def __init__(self, train_x, train_y, likelihood, lengthscale_constraint, outputscale_constraint, ard_dims):
super(GP, self).__init__(train_x, train_y, likelihood)
self.ard_dims = ard_dims
self.mean_module = ConstantMean()
base_kernel = MaternKernel(lengthscale_constraint=lengthscale_constraint, ard_num_dims=ard_dims, nu=2.5)
self.covar_module = ScaleKernel(base_kernel, outputscale_constraint=outputscale_constraint)
def forward(self, x):
mean_x = self.mean_module(x)
covar_x = self.covar_module(x)
return MultivariateNormal(mean_x, covar_x)
def train_gp(train_x, train_y, use_ard, num_steps, hypers={}):
"""Fit a GP model where train_x is in [0, 1]^d and train_y is standardized."""
assert train_x.ndim == 2
assert train_y.ndim == 1
assert train_x.shape[0] == train_y.shape[0]
# Create hyper parameter bounds
noise_constraint = Interval(5e-4, 0.2)
if use_ard:
lengthscale_constraint = Interval(0.005, 2.0)
else:
lengthscale_constraint = Interval(0.005, math.sqrt(train_x.shape[1])) # [0.005, sqrt(dim)]
outputscale_constraint = Interval(0.05, 20.0)
# Create models
likelihood = GaussianLikelihood(noise_constraint=noise_constraint).to(device=train_x.device, dtype=train_y.dtype)
ard_dims = train_x.shape[1] if use_ard else None
model = GP(
train_x=train_x,
train_y=train_y,
likelihood=likelihood,
lengthscale_constraint=lengthscale_constraint,
outputscale_constraint=outputscale_constraint,
ard_dims=ard_dims,
).to(device=train_x.device, dtype=train_x.dtype)
# Find optimal model hyperparameters
model.train()
likelihood.train()
# "Loss" for GPs - the marginal log likelihood
mll = ExactMarginalLogLikelihood(likelihood, model)
# Initialize model hypers
if hypers:
model.load_state_dict(hypers)
else:
hypers = {}
hypers["covar_module.outputscale"] = 1.0
hypers["covar_module.base_kernel.lengthscale"] = 0.5
hypers["likelihood.noise"] = 0.005
model.initialize(**hypers)
# Use the adam optimizer
optimizer = torch.optim.Adam([{"params": model.parameters()}], lr=0.1)
for _ in range(num_steps):
optimizer.zero_grad()
output = model(train_x)
loss = -mll(output, train_y)
loss.backward()
optimizer.step()
# Switch to eval mode
model.eval()
likelihood.eval()
return model
| 3,760 | 36.989899 | 117 | py |
TuRBO | TuRBO-master/turbo/turbo_1.py | ###############################################################################
# Copyright (c) 2019 Uber Technologies, Inc. #
# #
# Licensed under the Uber Non-Commercial License (the "License"); #
# you may not use this file except in compliance with the License. #
# You may obtain a copy of the License at the root directory of this project. #
# #
# See the License for the specific language governing permissions and #
# limitations under the License. #
###############################################################################
import math
import sys
from copy import deepcopy
import gpytorch
import numpy as np
import torch
from torch.quasirandom import SobolEngine
from .gp import train_gp
from .utils import from_unit_cube, latin_hypercube, to_unit_cube
class Turbo1:
"""The TuRBO-1 algorithm.
Parameters
----------
f : function handle
lb : Lower variable bounds, numpy.array, shape (d,).
ub : Upper variable bounds, numpy.array, shape (d,).
n_init : Number of initial points (2*dim is recommended), int.
max_evals : Total evaluation budget, int.
batch_size : Number of points in each batch, int.
verbose : If you want to print information about the optimization progress, bool.
use_ard : If you want to use ARD for the GP kernel.
max_cholesky_size : Largest number of training points where we use Cholesky, int
n_training_steps : Number of training steps for learning the GP hypers, int
min_cuda : We use float64 on the CPU if we have this or fewer datapoints
device : Device to use for GP fitting ("cpu" or "cuda")
dtype : Dtype to use for GP fitting ("float32" or "float64")
Example usage:
turbo1 = Turbo1(f=f, lb=lb, ub=ub, n_init=n_init, max_evals=max_evals)
turbo1.optimize() # Run optimization
X, fX = turbo1.X, turbo1.fX # Evaluated points
"""
def __init__(
self,
f,
lb,
ub,
n_init,
max_evals,
batch_size=1,
verbose=True,
use_ard=True,
max_cholesky_size=2000,
n_training_steps=50,
min_cuda=1024,
device="cpu",
dtype="float64",
):
# Very basic input checks
assert lb.ndim == 1 and ub.ndim == 1
assert len(lb) == len(ub)
assert np.all(ub > lb)
assert max_evals > 0 and isinstance(max_evals, int)
assert n_init > 0 and isinstance(n_init, int)
assert batch_size > 0 and isinstance(batch_size, int)
assert isinstance(verbose, bool) and isinstance(use_ard, bool)
assert max_cholesky_size >= 0 and isinstance(batch_size, int)
assert n_training_steps >= 30 and isinstance(n_training_steps, int)
assert max_evals > n_init and max_evals > batch_size
assert device == "cpu" or device == "cuda"
assert dtype == "float32" or dtype == "float64"
if device == "cuda":
assert torch.cuda.is_available(), "can't use cuda if it's not available"
# Save function information
self.f = f
self.dim = len(lb)
self.lb = lb
self.ub = ub
# Settings
self.n_init = n_init
self.max_evals = max_evals
self.batch_size = batch_size
self.verbose = verbose
self.use_ard = use_ard
self.max_cholesky_size = max_cholesky_size
self.n_training_steps = n_training_steps
# Hyperparameters
self.mean = np.zeros((0, 1))
self.signal_var = np.zeros((0, 1))
self.noise_var = np.zeros((0, 1))
self.lengthscales = np.zeros((0, self.dim)) if self.use_ard else np.zeros((0, 1))
# Tolerances and counters
self.n_cand = min(100 * self.dim, 5000)
self.failtol = np.ceil(np.max([4.0 / batch_size, self.dim / batch_size]))
self.succtol = 3
self.n_evals = 0
# Trust region sizes
self.length_min = 0.5 ** 7
self.length_max = 1.6
self.length_init = 0.8
# Save the full history
self.X = np.zeros((0, self.dim))
self.fX = np.zeros((0, 1))
# Device and dtype for GPyTorch
self.min_cuda = min_cuda
self.dtype = torch.float32 if dtype == "float32" else torch.float64
self.device = torch.device("cuda") if device == "cuda" else torch.device("cpu")
if self.verbose:
print("Using dtype = %s \nUsing device = %s" % (self.dtype, self.device))
sys.stdout.flush()
# Initialize parameters
self._restart()
def _restart(self):
self._X = []
self._fX = []
self.failcount = 0
self.succcount = 0
self.length = self.length_init
def _adjust_length(self, fX_next):
if np.min(fX_next) < np.min(self._fX) - 1e-3 * math.fabs(np.min(self._fX)):
self.succcount += 1
self.failcount = 0
else:
self.succcount = 0
self.failcount += 1
if self.succcount == self.succtol: # Expand trust region
self.length = min([2.0 * self.length, self.length_max])
self.succcount = 0
elif self.failcount == self.failtol: # Shrink trust region
self.length /= 2.0
self.failcount = 0
def _create_candidates(self, X, fX, length, n_training_steps, hypers):
"""Generate candidates assuming X has been scaled to [0,1]^d."""
# Pick the center as the point with the smallest function values
# NOTE: This may not be robust to noise, in which case the posterior mean of the GP can be used instead
assert X.min() >= 0.0 and X.max() <= 1.0
# Standardize function values.
mu, sigma = np.median(fX), fX.std()
sigma = 1.0 if sigma < 1e-6 else sigma
fX = (deepcopy(fX) - mu) / sigma
# Figure out what device we are running on
if len(X) < self.min_cuda:
device, dtype = torch.device("cpu"), torch.float64
else:
device, dtype = self.device, self.dtype
# We use CG + Lanczos for training if we have enough data
with gpytorch.settings.max_cholesky_size(self.max_cholesky_size):
X_torch = torch.tensor(X).to(device=device, dtype=dtype)
y_torch = torch.tensor(fX).to(device=device, dtype=dtype)
gp = train_gp(
train_x=X_torch, train_y=y_torch, use_ard=self.use_ard, num_steps=n_training_steps, hypers=hypers
)
# Save state dict
hypers = gp.state_dict()
# Create the trust region boundaries
x_center = X[fX.argmin().item(), :][None, :]
weights = gp.covar_module.base_kernel.lengthscale.cpu().detach().numpy().ravel()
weights = weights / weights.mean() # This will make the next line more stable
weights = weights / np.prod(np.power(weights, 1.0 / len(weights))) # We now have weights.prod() = 1
lb = np.clip(x_center - weights * length / 2.0, 0.0, 1.0)
ub = np.clip(x_center + weights * length / 2.0, 0.0, 1.0)
# Draw a Sobolev sequence in [lb, ub]
seed = np.random.randint(int(1e6))
sobol = SobolEngine(self.dim, scramble=True, seed=seed)
pert = sobol.draw(self.n_cand).to(dtype=dtype, device=device).cpu().detach().numpy()
pert = lb + (ub - lb) * pert
# Create a perturbation mask
prob_perturb = min(20.0 / self.dim, 1.0)
mask = np.random.rand(self.n_cand, self.dim) <= prob_perturb
ind = np.where(np.sum(mask, axis=1) == 0)[0]
mask[ind, np.random.randint(0, self.dim - 1, size=len(ind))] = 1
# Create candidate points
X_cand = x_center.copy() * np.ones((self.n_cand, self.dim))
X_cand[mask] = pert[mask]
# Figure out what device we are running on
if len(X_cand) < self.min_cuda:
device, dtype = torch.device("cpu"), torch.float64
else:
device, dtype = self.device, self.dtype
# We may have to move the GP to a new device
gp = gp.to(dtype=dtype, device=device)
# We use Lanczos for sampling if we have enough data
with torch.no_grad(), gpytorch.settings.max_cholesky_size(self.max_cholesky_size):
X_cand_torch = torch.tensor(X_cand).to(device=device, dtype=dtype)
y_cand = gp.likelihood(gp(X_cand_torch)).sample(torch.Size([self.batch_size])).t().cpu().detach().numpy()
# Remove the torch variables
del X_torch, y_torch, X_cand_torch, gp
# De-standardize the sampled values
y_cand = mu + sigma * y_cand
return X_cand, y_cand, hypers
def _select_candidates(self, X_cand, y_cand):
"""Select candidates."""
X_next = np.ones((self.batch_size, self.dim))
for i in range(self.batch_size):
# Pick the best point and make sure we never pick it again
indbest = np.argmin(y_cand[:, i])
X_next[i, :] = deepcopy(X_cand[indbest, :])
y_cand[indbest, :] = np.inf
return X_next
def optimize(self):
"""Run the full optimization process."""
while self.n_evals < self.max_evals:
if len(self._fX) > 0 and self.verbose:
n_evals, fbest = self.n_evals, self._fX.min()
print(f"{n_evals}) Restarting with fbest = {fbest:.4}")
sys.stdout.flush()
# Initialize parameters
self._restart()
# Generate and evalute initial design points
X_init = latin_hypercube(self.n_init, self.dim)
X_init = from_unit_cube(X_init, self.lb, self.ub)
fX_init = np.array([[self.f(x)] for x in X_init])
# Update budget and set as initial data for this TR
self.n_evals += self.n_init
self._X = deepcopy(X_init)
self._fX = deepcopy(fX_init)
# Append data to the global history
self.X = np.vstack((self.X, deepcopy(X_init)))
self.fX = np.vstack((self.fX, deepcopy(fX_init)))
if self.verbose:
fbest = self._fX.min()
print(f"Starting from fbest = {fbest:.4}")
sys.stdout.flush()
# Thompson sample to get next suggestions
while self.n_evals < self.max_evals and self.length >= self.length_min:
# Warp inputs
X = to_unit_cube(deepcopy(self._X), self.lb, self.ub)
# Standardize values
fX = deepcopy(self._fX).ravel()
# Create th next batch
X_cand, y_cand, _ = self._create_candidates(
X, fX, length=self.length, n_training_steps=self.n_training_steps, hypers={}
)
X_next = self._select_candidates(X_cand, y_cand)
# Undo the warping
X_next = from_unit_cube(X_next, self.lb, self.ub)
# Evaluate batch
fX_next = np.array([[self.f(x)] for x in X_next])
# Update trust region
self._adjust_length(fX_next)
# Update budget and append data
self.n_evals += self.batch_size
self._X = np.vstack((self._X, X_next))
self._fX = np.vstack((self._fX, fX_next))
if self.verbose and fX_next.min() < self.fX.min():
n_evals, fbest = self.n_evals, fX_next.min()
print(f"{n_evals}) New best: {fbest:.4}")
sys.stdout.flush()
# Append data to the global history
self.X = np.vstack((self.X, deepcopy(X_next)))
self.fX = np.vstack((self.fX, deepcopy(fX_next)))
| 11,981 | 38.675497 | 117 | py |
lisa | lisa-master/devel/unet_keras_kidney_bodynavigation.py | # %%
# %%
from __future__ import print_function
from loguru import logger
import io3d
import io3d.datasets
import sed3
import numpy as np
import matplotlib.pyplot as plt
logger.enable("io3d")
logger.disable("io3d")
import matplotlib.pyplot as plt
from pathlib import Path
import bodynavigation
import exsu
import sys
import os
import tensorflow as tf
import os
from skimage.transform import resize
from skimage.io import imsave
import numpy as np
from skimage.segmentation import mark_boundaries
import tensorflow.keras
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, Conv2DTranspose
from tensorflow.keras.optimizers import Adam, SGD
from tensorflow.keras.callbacks import ModelCheckpoint
from tensorflow.keras import backend as K
from tensorflow.keras.callbacks import History
from skimage.exposure import rescale_intensity
from skimage import io
# from data import load_train_data, load_test_data
from sklearn.utils import class_weight
from typing import Optional
from numbers import Number
import datetime
from unet_keras_tools import window, create_train_data, load_test_data, load_train_data, UNetTrainer, save_segmentations, get_dataset_loaders
# %%
print("Num GPUs Available: ", len(tf.config.experimental.list_physical_devices('GPU')))
print(sys.version_info)
print(sys.executable)
print(os.getcwd())
# %%
experiment_label = "rightkidney_slides_bodynavigation_1"
organ_label = "rightkidney"
show=False
# %%
dtstr = datetime.datetime.now().strftime("%Y%m%d_%H%M")
rdir = f"report_{experiment_label}_{dtstr}"
report = exsu.Report(outputdir=rdir, show=show, additional_spreadsheet_fn="data.xlsx")
reporti=0
# %%
datap1 = io3d.datasets.read_dataset("3Dircadb1", "data3d", 1)
# datap1 = io3d.datasets.read_dataset("sliver07", "data3d", 1)
data3d = datap1["data3d"]
sed3.show_slices(data3d, shape=[2, 3], show=show)
report.savefig(f"{reporti:03d}.png")
reporti += 1
# %%
datap_mask = io3d.datasets.read_dataset("3Dircadb1", organ_label, 1)
data3d_mask = datap_mask["data3d"]
sed3.show_slices(data3d_mask, shape=[2, 3], show=show)
report.savefig(f"{reporti:03d}.png")
reporti += 1
# plt.figure()
# %% md
## windowing
# %%
data3dw = window(data3d, center=40, width=400)
# fix, axs = plt.subplots(1,2)
# axs[]
# plt.imshow(data3d[30, :, :], cmap='gray')
# plt.colorbar()
#
# plt.figure()
#
# plt.imshow(data3dw[30, :, :], cmap='gray')
# plt.colorbar()
#
# %% md
## bodynavigation
# %%
bn = bodynavigation.body_navigation.BodyNavigation(datap1["data3d"], voxelsize_mm=datap1["voxelsize_mm"])
dst = bn.dist_to_sagittal()
plt.imshow(data3d[30, :, :], cmap="gray")
plt.contour(dst[30, :, :] > 0)
report.savefig(f"{reporti:03d}.png")
reporti += 1
# %%
# %%
a = np.asarray([np.stack([data3d[0, :, :], data3d[1, :, :]], axis=2)])
a.shape
# %%
# %%
skip_if_exists = True
create_train_data(
"train",
datasets={
# "3Dircadb1": {"start":1, "stop":5},
"3Dircadb1": {"start":1, "stop":16},
# "sliver07": {"start":1, "stop":16}
},
dataset_label=experiment_label,
organ_label=organ_label,
skip_if_exists=skip_if_exists
)
create_train_data(
"test",
datasets={
"3Dircadb1": {"start":16, "stop":21},
# "sliver07": {"start":16, "stop":20}
},
dataset_label= experiment_label,
organ_label = organ_label,
skip_if_exists=skip_if_exists
)
# %%
# %%
# %% md
# CNN
# %% md
# conda install -c conda-forge keras-applications
# %%
# %%
# %%
data_oh = tf.one_hot(datap_mask['data3d'], 2)
print(data_oh.shape)
# print(data_oh)
sed3.show_slices(data_oh.numpy()[:, :, :, 0].squeeze(), shape=[2, 3], show=show)
report.savefig(f"{reporti:03d}.png")
reporti += 1
# %%
K.set_image_data_format('channels_last') # TF dimension ordering in this code
img_rows = int(512 / 2)
img_cols = int(512 / 2)
# We divide here the number of rows and columns by two because we undersample our data (We take one pixel over two)
# %%
# wbc = weighted_binary_crossentropy(0.5, 0.5)
# u = wbc(np.array([1,1,0,1], dtype=np.float32).reshape(4,1,1,1), np.array([1,1,0,1], dtype=np.float32).reshape(4,1,1,1))
# %%
# return imgs_train, imgs_mask_train
# %%
f"__{10:04}.png"
# %%
# weights_dct
# %%
nb_channels=2
unt = UNetTrainer(nb_channels, img_rows, img_cols, experiment_label, organ_label=organ_label)
history = unt.train_and_predict(epochs=1, step=1)
# history = train_and_predict(continue_training=True, epochs=10)
# %%
## Recalculate predictions for train dataset
# imgs_train, imgs_mask_train = load_test_data()
# imgs_train = preprocess(imgs_train)
# imgs_mask_train = preprocess(imgs_mask_train)
# imgs_train = imgs_train.astype('float32')
# mean = np.mean(imgs_train) # mean for data centering
# std = np.std(imgs_train) # std for data normalization
unt.predict_test_data(history)
# %% md
# Try one image
# %%
imgs_train, imgs_mask_train = get_dataset_loaders("train", organ_label)
imgs_train = unt.preprocess(imgs_train)
imgs_mask_train = unt.preprocess(imgs_mask_train)
imgs_train = imgs_train.astype('float32')
# mean = np.mean(imgs_train) # mean for data centering
# std = np.std(imgs_train) # std for data normalization
# imgs_train -= mean
# imgs_train /= std
# Normalization of the train set
imgs_mask_train = imgs_mask_train.astype('float32')
print(f"Number of frames={imgs_train.shape[0]}")
# %%
# ---------------------------------------------------------
unt = UNetTrainer(nb_channels, img_rows, img_cols, experiment_label)
model = unt.get_unet()
model.load_weights(f'weights_{experiment_label}.h5')
logger.debug('-' * 30)
logger.debug('Predicting masks on test data...')
logger.debug('-' * 30)
imgs_mask_train_pred = model.predict(imgs_train, verbose=1)
# %%
import scipy.stats
logger.debug(scipy.stats.describe(imgs_mask_train_pred.flatten()))
# %%
i = 86
# %%
plt.imshow(imgs_train[i, :, :, 0], cmap='gray')
plt.colorbar()
report.savefig(f"img_{i}.png")
# %%
plt.imshow(imgs_mask_train_pred[i, :, :], cmap='gray')
plt.colorbar()
report.savefig(f"mask_pred_{i}.png")
# %%
plt.imshow(imgs_mask_train[i, :, :], cmap='gray')
plt.colorbar()
report.savefig(f"mask_true_{i}.png")
# %%
logger.debug(tf.keras.losses.binary_crossentropy(imgs_mask_train[i, :, :].flatten(), imgs_mask_train_pred[i, :, :].flatten()))
# %%
logger.debug(tf.keras.losses.binary_crossentropy(imgs_mask_train.flatten(), imgs_mask_train_pred.flatten()))
# %%
save_segmentations(imgs_train[:, :, :, 0], imgs_mask_train_pred[..., 0], f"preds_test/{experiment_label}")
# %%
y_train = (imgs_mask_train > 0).astype(np.float32)
weights = class_weight.compute_class_weight('balanced', np.unique(y_train.flatten()), y_train.flatten())
# y_train.shape
# imgs_train.shape
# y_train.dtype
# print(np.unique(imgs_mask_train > 0))
# plt.imshow(imgs_mask_train[150,:,:] > 0, interpolation='None')
logger.debug(weights)
# %%
| 6,930 | 19.813814 | 141 | py |
lisa | lisa-master/devel/unet_keras_tools.py | from __future__ import print_function
from loguru import logger
import io3d
import io3d.datasets
import sed3
import numpy as np
import matplotlib.pyplot as plt
logger.enable("io3d")
logger.disable("io3d")
import matplotlib.pyplot as plt
from pathlib import Path
import bodynavigation
import exsu
import sys
import os
import tensorflow as tf
import os
from skimage.transform import resize
from skimage.io import imsave
import numpy as np
from skimage.segmentation import mark_boundaries
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, concatenate, Conv2D, MaxPooling2D, Conv2DTranspose
from tensorflow.keras.optimizers import Adam, SGD
from tensorflow.keras.callbacks import ModelCheckpoint
from tensorflow.keras import backend as K
from tensorflow.keras.callbacks import History
from skimage.exposure import rescale_intensity
from skimage import io
# from data import load_train_data, load_test_data
from sklearn.utils import class_weight
from typing import Optional
from numbers import Number
def window(
data3d: np.ndarray,
vmin: Optional[Number] = None,
vmax: Optional[Number] = None,
center: Optional[Number] = None,
width: Optional[Number] = None,
vmin_out: Optional[Number] = 0,
vmax_out: Optional[Number] = 255,
dtype=np.uint8):
"""
Rescale input ndarray and trim the outlayers.
:param data3d: ndarray with numbers
:param vmin: minimal input value. Skipped if center and width is given.
:param vmax: maximal input value. Skipped if center and width is given.
:param center: Window center
:param width: Window width
:param vmin_out: Output mapping minimal value
:param vmax_out: Output mapping maximal value
:param dtype: Output dtype
:return:
"""
if width and center:
vmin = center - (width / 2.)
vmax = center + (width / 2.)
# logger.debug(f"vmin={vmin}, vmax={vmax}")
k = float(vmax_out - vmin_out) / (vmax - vmin)
q = vmax_out - k * vmax
# logger.debug(f"k={k}, q={q}")
data3d_out = data3d * k + q
data3d_out[data3d_out > vmax_out] = vmax_out
data3d_out[data3d_out < vmin_out] = vmin_out
return data3d_out.astype(dtype)
import h5py
import tensorflow as tf
class generator:
def __init__(self, label, organ_label, is_mask=False):
self.label = label
self.organ_label = organ_label
self.is_mask=is_mask
def __call__(self):
fnimgs = Path(f'mask_{self.label}_{self.organ_label}') if self.is_mask else Path(f'img_{self.label}')
for indx in range(len(fnimgs.glob("*.npy"))):
fnimg = fnimgs / f"{indx:06d}.npy"
img = np.load(fnimg)
yield img
# with h5py.File(self.file, 'r') as hf:
# for im in hf["train_img"]:
# imgs_train = np.load(f'imgs_train_{experiment_label}.npy')
# yield im
def load_train_data(experiment_label):
imgs_train = np.load(f'imgs_train_{experiment_label}.npy')
masks_train = np.load(f'masks_train_{experiment_label}.npy')
return imgs_train, masks_train
def load_test_data(experiment_label):
imgs_test = np.load(f'imgs_test_{experiment_label}.npy')
masks_test = np.load(f'masks_test_{experiment_label}.npy')
return imgs_test, masks_test
def get_dataset_loaders(label, organ_label):
imgs = tf.data.Dataset.from_generator(
generator(label, organ_label, is_mask=False),
tf.uint8,
tf.TensorShape([512, 512, 3]))
masks = tf.data.Dataset.from_generator(
generator(label, organ_label, is_mask=True),
tf.uint8,
tf.TensorShape([512, 512, 3]))
return imgs, masks
def create_train_data(label="train", datasets=None, dataset_label="", organ_label="rightkidney", skip_if_exists=True):
# fnimgs = f'imgs_{label}_{dataset_label}.npy'
# fnmasks =f'masks_{label}_{dataset_label}.npy'
fnimgs = Path(f'img_{label}_{dataset_label}')
fnmasks =Path(f'mask_{label}_{dataset_label}_{organ_label}')
fnpattern = "{dataset}_{i:02d}_{k:05d}.npy"
p_imgs = fnimgs
p_masks =fnmasks
# if p_imgs.exists() and p_imgs.is_dir() and p_masks.exists() and p_masks.is_dir() and skip_if_exists:
# logger.info("Files exists. Skipping creation and loading instead.")
# # imgs_train = np.load(fnimgs)
# # masks_train = np.load(fnmasks)
if True:
# imgs_train = []
# masks_train = []
if not datasets:
datasets = {
"3Dircadb1": {"start": 1, "stop": 2},
# "sliver07": {"start":0, "stop":0}
}
indx = 0
for dataset in datasets:
for i in range(
datasets[dataset]["start"],
datasets[dataset]["stop"]
):
logger.debug(f"{dataset} {i}")
fn0 = fnpattern.format(dataset=dataset, i=i, k=0)
if not (fnmasks / fn0).exists():
# logger.info(f"File {fn0} exists. Skipping")
# continue
segm3dp = io3d.datasets.read_dataset(dataset, organ_label, i)
if segm3dp is None:
logger.info(f" Organ label '{organ_label}' does not exist. Skipping.")
continue
segm3d = segm3dp["data3d"]
fnmasks.mkdir(parents=True, exist_ok=True)
for k in range(segm3dp.data3d.shape[0]):
np.save(fnmasks / fnpattern.format(dataset=dataset, i=i, k=k) , segm3d[k])
if not (fnimgs / fn0).exists():
data3dp = io3d.datasets.read_dataset(dataset, "data3d", i)
data3d = window(data3dp["data3d"], center=40, width=400, vmin_out=0, vmax_out=255, dtype=np.uint8)
bn = bodynavigation.body_navigation.BodyNavigation(data3dp["data3d"], voxelsize_mm=data3dp["voxelsize_mm"])
feature_list = [
data3d,
bn.dist_to_sagittal(),
bn.dist_coronal(),
bn.dist_to_diaphragm_axial(),
bn.dist_to_surface(),
]
# print(f"shapes: data3d={data3d.shape}, dst={dst.shape}")
# for j in range(0, data3d.shape[0]):
# imgs_train.append(np.stack([data3d[j, :, :], feature_list[0][j, :, :]], axis=2))
# masks_train.append(segm3d[j, :, :])
all_features = expand_dims_and_concat(feature_list, 3)
fnimgs.mkdir(parents=True, exist_ok=True)
for k in range(all_features.shape[0]):
np.save(fnimgs / fnpattern.format(dataset=dataset, i=i, k=k), all_features[k])
indx += 1
logger.debug(f"i={i}, {all_features.shape}")
# imgs_train = np.array(imgs_train, dtype=np.int16)
# masks_train = np.array(masks_train, dtype=np.uint8)
# np.save(fnimgs, imgs_train)
# np.save(fnmasks, masks_train)
# print(f'Saving to .npy files done. imgs.shape={imgs_train.shape}, masks.shape={masks_train.shape}')
# return imgs_train, masks_train
def dice_coef(y_true, y_pred):
smooth = 1.
y_true_f = K.flatten(y_true)
y_pred_f = K.flatten(y_pred)
intersection = K.sum(y_true_f * y_pred_f)
return (2. * intersection + smooth) / (K.sum(y_true_f) + K.sum(y_pred_f) + smooth)
def dice_coef_loss(y_true, y_pred):
return -dice_coef(y_true, y_pred)
# The functions return our metric and loss
# %%
# one_weight = (1-num_of_ones)/(num_of_ones + num_of_zeros)
# zero_weight = (1-num_of_zeros)/(num_of_ones + num_of_zeros)
def weighted_binary_crossentropy(zero_weight, one_weight):
def weighted_binary_crossentropy(y_true, y_pred):
b_ce = K.binary_crossentropy(y_true, y_pred)
# weighted calc
weight_vector = y_true * one_weight + (1 - y_true) * zero_weight
weighted_b_ce = weight_vector * b_ce
return K.mean(weighted_b_ce)
return weighted_binary_crossentropy
def save_segmentations(imgs_test, imgs_mask_test, pred_dir='preds'):
print(f"shapes={imgs_test.shape},{imgs_mask_test.shape}")
if not os.path.exists(pred_dir):
os.mkdir(pred_dir)
for k in range(len(imgs_mask_test)):
a = rescale_intensity(imgs_test[k][:, :], out_range=(-1, 1))
b = (imgs_mask_test[k][:, :] > 0.5).astype('uint8')
io.imsave(os.path.join(pred_dir, f'{k:05}_pred.png'), mark_boundaries(a, b))
# nb_channels = 2
class UNetTrainer():
def __init__(self, nb_channels, img_rows, img_cols, experiment_label, organ_label):
self.nb_channels = nb_channels
self.img_rows = img_rows
self.img_cols = img_cols
self.experiment_label = experiment_label
self.organ_label = organ_label
pass
def get_unet(self, weights=None):
if weights is None:
weights = [0.05956, 3.11400]
# {0: 0.5956388648542532, 1: 3.1140000760253925}
inputs = Input((self.img_rows, self.img_cols, self.nb_channels))
conv1 = Conv2D(32, (3, 3), activation='relu', padding='same')(inputs)
conv1 = Conv2D(32, (3, 3), activation='relu', padding='same')(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = Conv2D(64, (3, 3), activation='relu', padding='same')(pool1)
conv2 = Conv2D(64, (3, 3), activation='relu', padding='same')(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = Conv2D(128, (3, 3), activation='relu', padding='same')(pool2)
conv3 = Conv2D(128, (3, 3), activation='relu', padding='same')(conv3)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = Conv2D(256, (3, 3), activation='relu', padding='same')(pool3)
conv4 = Conv2D(256, (3, 3), activation='relu', padding='same')(conv4)
pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)
conv5 = Conv2D(512, (3, 3), activation='relu', padding='same')(pool4)
conv5 = Conv2D(512, (3, 3), activation='relu', padding='same')(conv5)
up6 = concatenate([Conv2DTranspose(256, (2, 2), strides=(2, 2), padding='same')(conv5), conv4], axis=3)
conv6 = Conv2D(256, (3, 3), activation='relu', padding='same')(up6)
conv6 = Conv2D(256, (3, 3), activation='relu', padding='same')(conv6)
up7 = concatenate([Conv2DTranspose(128, (2, 2), strides=(2, 2), padding='same')(conv6), conv3], axis=3)
conv7 = Conv2D(128, (3, 3), activation='relu', padding='same')(up7)
conv7 = Conv2D(128, (3, 3), activation='relu', padding='same')(conv7)
up8 = concatenate([Conv2DTranspose(64, (2, 2), strides=(2, 2), padding='same')(conv7), conv2], axis=3)
conv8 = Conv2D(64, (3, 3), activation='relu', padding='same')(up8)
conv8 = Conv2D(64, (3, 3), activation='relu', padding='same')(conv8)
up9 = concatenate([Conv2DTranspose(32, (2, 2), strides=(2, 2), padding='same')(conv8), conv1], axis=3)
conv9 = Conv2D(32, (3, 3), activation='relu', padding='same')(up9)
conv9 = Conv2D(32, (3, 3), activation='relu', padding='same')(conv9)
conv10 = Conv2D(1, (1, 1), activation='sigmoid')(conv9)
# conv10 = Conv2D(2, (1, 1), activation='softmax')(conv9)
model = Model(inputs=[inputs], outputs=[conv10])
# model.compile(optimizer=Adam(lr=1e-3), loss=dice_coef_loss, metrics=[dice_coef])
# model.compile(optimizer='adam', loss='binary_crossentropy', metrics=[dice_coef, "accuracy"])
model.compile(optimizer='adam', loss=weighted_binary_crossentropy(weights[0], weights[1]),
metrics=[dice_coef, "accuracy"])
# model.compile(optimizer='adam', loss=weighted_binary_crossentropy(weights[0], weights[1]), metrics=[dice_coef, "accuracy"]) # categorical crossentropy (weighted)
return model
# The different layers in our neural network model (including convolutions, maxpooling and upsampling)
# %%
def preprocess(self, imgs, is_mask=False):
new_shape = list(imgs.shape).copy()
new_shape[1] = self.img_rows
new_shape[2] = self.img_cols
# imgs_p = np.ndarray((imgs.shape[0], img_rows, img_cols, imgs.shape[3]), dtype=np.uint8)
imgs_p = np.ndarray(new_shape, dtype=np.uint8)
for i in range(imgs.shape[0]):
imgs_p[i] = resize(imgs[i], new_shape[1:], preserve_range=True)
# imgs_p[i] = resize(imgs[i, 0 ], (img_cols, img_rows), preserve_range=True)
# imgs_p = imgs_p[..., np.newaxis]
if is_mask:
imgs_p = (imgs_p > 0).astype('float32')
else:
imgs_p = imgs_p.astype('float32')
return imgs_p
# We adapt here our dataset samples dimension so that we can feed it to our network
# %%
# %%
def train_and_predict(self, continue_training=False, epochs=50, step=1):
# if True:
print('-' * 30)
print('Loading and preprocessing train data...')
print('-' * 30)
experiment_label = self.experiment_label
# imgs_train, imgs_mask_train = load_train_data(self.experiment_label)
imgs_train, imgs_mask_train = get_dataset_loaders("train", self.organ_label)
imgs_train = imgs_train[::step]
imgs_mask_train = imgs_mask_train[::step]
logger.debug(f"imgs_train.shape={imgs_train.shape}")
logger.debug(f"imgs_mask_train.shape={imgs_mask_train.shape}")
imgs_train = self.preprocess(imgs_train)
imgs_mask_train = self.preprocess(imgs_mask_train, is_mask=True)
logger.debug(f"imgs_train.shape={imgs_train.shape}")
logger.debug(f"imgs_mask_train.shape={imgs_mask_train.shape}")
# TODO remove - using small part of dataset
# imgs_train = imgs_train[50:65]
# imgs_mask_train = imgs_mask_train[50:65]
# imgs_train = imgs_train.astype('float32')
# mean = np.mean(imgs_train) # mean for data centering
# std = np.std(imgs_train) # std for data normalization
# imgs_train -= mean
# imgs_train /= std
# Normalization of the train set
# imgs_mask_train = (imgs_mask_train > 0).astype('float32')
y_train = imgs_mask_train
# Calculate the weights for each class so that we can balance the data
cl_weights = class_weight.compute_class_weight(
'balanced',
np.unique(y_train.flatten()),
y_train.flatten()
)
print(f"weights={cl_weights}")
cl_weights_dct = dict(enumerate(cl_weights))
print('-' * 30)
print('Creating and compiling model...')
print('-' * 30)
model = self.get_unet(cl_weights)
if continue_training:
model.load_weights(f'weights_{experiment_label}.h5')
model_checkpoint = ModelCheckpoint(f'weights_{experiment_label}.h5', monitor='val_loss', save_best_only=True)
# Saving the weights and the loss of the best predictions we obtained
print('-' * 30)
print('Fitting model...')
print('-' * 30)
log_dir = f'logs\\{experiment_label}\\'
# Path(log_dir).mkdir(parents=True, exist_ok=True)
model.fit_generator()
history = model.fit(
imgs_train, imgs_mask_train, batch_size=10, epochs=epochs, verbose=1, shuffle=True,
validation_split=0.2,
callbacks=[
model_checkpoint,
tf.keras.callbacks.TensorBoard(log_dir=log_dir)
],
# class_weight=weights_dct # tohle nefunguje pro 4d data
)
# predict_test_data(mean=None, std=None)
self.predict_test_data(history)
return history
def predict_test_data(self, history):
print('-' * 30)
print('Loading and preprocessing test data...')
print('-' * 30)
# imgs_test, imgs_maskt = load_test_data(self.experiment_label)
imgs_test, imgs_maskt = get_dataset_loaders("test", self.organ_label)
imgs_test = self.preprocess(imgs_test)
imgs_maskt = self.preprocess(imgs_maskt, is_mask=True)
y_train = imgs_maskt
# Calculate the weights for each class so that we can balance the data
cl_weights = class_weight.compute_class_weight(
'balanced',
np.unique(y_train.flatten()),
y_train.flatten()
)
model = self.get_unet(cl_weights)
# TODO remove this limit
# imgs_test = imgs_test[50:65]
# imgs_maskt = imgs_maskt[50:65]
imgs_test = imgs_test.astype('float32')
# imgs_test -= mean
# imgs_test /= std
# Normalization of the test set
# TODO remove this part
# going to test on train set
# imgs_test = imgs_train
# imgs_maskt = imgs_mask_train
print('-' * 30)
print('Loading saved weights...')
print('-' * 30)
model.load_weights(f'weights_{self.experiment_label}.h5')
print('-' * 30)
print('Predicting masks on test data...')
print('-' * 30)
imgs_mask_test = model.predict(imgs_test, verbose=1)
np.save('imgs_mask_test.npy', imgs_mask_test)
print('-' * 30)
print('Saving predicted masks to files...')
print('-' * 30)
pred_dir = f"preds/{self.experiment_label}"
Path(pred_dir).mkdir(parents=True, exist_ok=True)
# Saving our predictions in the directory 'preds'
logger.debug(f"imgs_test.shape={imgs_test.shape}")
logger.debug(f"imgs_mask_test.shape={imgs_mask_test.shape}")
# save_segmentations(imgs_test[:, :, :, 0, 0], imgs_mask_test[:, :, :, 0], pred_dir=pred_dir)
save_segmentations(imgs_test[:, :, :, 0], imgs_mask_test[:, :, :, 0], pred_dir=pred_dir)
plt.plot(history.history['dice_coef'])
plt.plot(history.history['val_dice_coef'])
plt.title('Model dice coeff')
plt.ylabel('Dice coeff')
plt.xlabel('Epoch')
plt.legend(['Train', 'Test'], loc='upper left')
plt.show()
# plotting our dice coeff results in function of the number of epochs
def load_batch():
pass
def expand_dims_and_concat(larr:np.ndarray, axis:int):
larr = list(map(lambda x: np.expand_dims(x,axis), larr))
arr = np.concatenate(larr, axis=axis)
return arr
| 18,662 | 37.401235 | 173 | py |
LineaRE | LineaRE-master/dataloader.py | import numpy as np
import torch
from torch.utils.data import Dataset
from config import config
class TrainDataset(Dataset):
def __init__(self, triples, ent_num, neg_size, mode):
self.triples = triples
self.ent_num = ent_num
self.neg_size = neg_size
self.neg_sample_size = neg_size + neg_size // 3
self.mode = mode
self.true_ents, self.weights = self.get_true_ents(self.triples, mode)
def __len__(self):
return len(self.triples)
def __getitem__(self, idx):
pos_sample = self.triples[idx]
if self.mode == "head-batch":
_, r, e = pos_sample
else:
e, r, _ = pos_sample
neg_list = []
neg_num = 0
while neg_num < self.neg_size: # 采 neg_size 个负样本
neg_sample = np.random.randint(self.ent_num, size=self.neg_sample_size)
mask = np.in1d(neg_sample, self.true_ents[(e, r)], assume_unique=True, invert=True)
neg_sample = neg_sample[mask] # 滤除 False 处的值
neg_list.append(neg_sample) # 内容为 array
neg_num += neg_sample.size
neg_sample = np.concatenate(neg_list)[:self.neg_size] # 合并, 去掉多余的
neg_sample = torch.from_numpy(neg_sample).long()
pos_sample = torch.tensor(pos_sample)
return pos_sample, neg_sample, self.weights[(e, r)], self.mode
@staticmethod
def collate_fn(data):
pos_sample = torch.stack([_[0] for _ in data])
neg_sample = torch.stack([_[1] for _ in data])
weight = torch.tensor([_[2] for _ in data])
return pos_sample, neg_sample, torch.reciprocal(weight), data[0][3]
@staticmethod
def get_true_ents(triples, mode):
true_ents = {}
weights = {}
for triple in triples:
if mode == "head-batch":
e2, r, e1 = triple
elif mode == "tail-batch":
e1, r, e2 = triple
else:
raise ValueError("Training batch mode %s not supported" % mode)
if (e1, r) not in true_ents:
true_ents[(e1, r)] = []
true_ents[(e1, r)].append(e2)
for e1r in true_ents:
true_ents[e1r] = np.array(true_ents[e1r])
weights[e1r] = true_ents[e1r].size ** config.sampling_rate
return true_ents, weights
class TestDataset(Dataset):
def __init__(self, triples, true_ents, ent_num, mode, r_tp):
self.triples = triples
self.ent_num = ent_num
self.true_ents = true_ents
self.mode = mode
self.r_tp = r_tp # 关系类型
def __len__(self):
return len(self.triples)
def __getitem__(self, idx):
sample = self.triples[idx]
h, r, t = sample
tmp = np.zeros(self.ent_num, dtype=np.float32)
if self.mode == "head-batch":
for hh in self.true_ents[(r, t)]:
tmp[hh] = 100.0
tmp[h] = 0.0
elif self.mode == "tail-batch":
for tt in self.true_ents[(h, r)]:
tmp[tt] = 100.0
tmp[t] = 0.0
else:
raise ValueError("negative batch mode %s not supported" % self.mode)
filter_bias = torch.from_numpy(tmp)
sample = torch.tensor(sample)
return sample, filter_bias, self.mode, self.r_tp[r]
@staticmethod
def collate_fn(data):
pos_sample = torch.stack([_[0] for _ in data])
filter_bias = torch.stack([_[1] for _ in data])
rel_tp = np.array([_[3] for _ in data])
return pos_sample, filter_bias, data[0][2], rel_tp
class BidirectionalOneShotIterator(object):
def __init__(self, dataloader_head, dataloader_tail):
self.iterator_head = self.one_shot_iterator(dataloader_head)
self.iterator_tail = self.one_shot_iterator(dataloader_tail)
self.step = 0
def __next__(self):
self.step += 1
if self.step % 2 == 0: # head 和 tail 交替返回
data = next(self.iterator_head)
else:
data = next(self.iterator_tail)
return data
@staticmethod
def one_shot_iterator(dataloader):
while True:
for data in dataloader:
yield data
| 4,204 | 32.64 | 95 | py |
LineaRE | LineaRE-master/utils.py | import json
import logging
import os
import numpy as np
import torch
import torch.nn.functional as func
from torch.utils.data import DataLoader
from config import config
from dataloader import TrainDataset, BidirectionalOneShotIterator, TestDataset
def read_elements(file_path):
with open(file_path, 'r') as f:
elements2id = {}
for line in f:
e_id, e_str = line.strip().split('\t')
elements2id[e_str] = int(e_id)
return elements2id
def read_triples(file_path, ent2id, rel2id):
triples = []
with open(file_path, 'r') as f:
for line in f:
h, r, t = line.strip().split('\t')
triples.append((ent2id[h], rel2id[r], ent2id[t]))
return triples
def get_true_ents(triples):
true_heads = {}
true_tails = {}
for h, r, t in triples:
if (r, t) not in true_heads:
true_heads[(r, t)] = []
true_heads[(r, t)].append(h)
if (h, r) not in true_tails:
true_tails[(h, r)] = []
true_tails[(h, r)].append(t)
for rt in true_heads:
true_heads[rt] = np.array(true_heads[rt])
for hr in true_tails:
true_tails[hr] = np.array(true_tails[hr])
return true_heads, true_tails
def rel_type(triples):
count_r = {}
count_h = {}
count_t = {}
for h, r, t in triples:
if r not in count_r:
count_r[r] = 0
count_h[r] = set()
count_t[r] = set()
count_r[r] += 1
count_h[r].add(h)
count_t[r].add(t)
r_tp = {}
for r in range(len(count_r)):
tph = count_r[r] / len(count_h[r])
hpt = count_r[r] / len(count_t[r])
if hpt < 1.5:
if tph < 1.5:
r_tp[r] = 1 # 1-1
else:
r_tp[r] = 2 # 1-M
else:
if tph < 1.5:
r_tp[r] = 3 # M-1
else:
r_tp[r] = 4 # M-M
return r_tp
def save_model(model, optimizer, save_vars):
# 保存 config
config_dict = vars(config)
with open(os.path.join(config.save_path, "config.json"), 'w') as fjson:
json.dump(config_dict, fjson)
# 保存某些变量、模型参数、优化器参数
torch.save(
{
**save_vars,
"model_state_dict": model.state_dict(),
"optimizer_state_dict": optimizer.state_dict()
},
os.path.join(config.save_path, "checkpoint")
)
# 保存 embedding
ent_embd = model.ent_embd.weight.detach().cpu().numpy()
np.save(
os.path.join(config.save_path, "ent_embd"),
ent_embd
)
rel_embd = model.rel_embd.weight.detach().cpu().numpy()
np.save(
os.path.join(config.save_path, "rel_embd"),
rel_embd
)
if config.model == "TransH":
wr = model.wr.weight.detach().cpu().numpy()
np.save(
os.path.join(config.save_path, "wr"),
wr
)
elif config.model == "TransR":
mr = model.mr.weight.detach().cpu().numpy()
np.save(
os.path.join(config.save_path, "mr"),
mr
)
elif config.model == "TransD":
ent_p = model.ent_p.weight.detach().cpu().numpy()
np.save(
os.path.join(config.save_path, "ent_p"),
ent_p
)
rel_p = model.rel_p.weight.detach().cpu().numpy()
np.save(
os.path.join(config.save_path, "rel_p"),
rel_p
)
elif config.model == "STransE":
mr1 = model.mr1.weight.detach().cpu().numpy()
np.save(
os.path.join(config.save_path, "mr1"),
mr1
)
mr2 = model.mr2.weight.detach().cpu().numpy()
np.save(
os.path.join(config.save_path, "mr2"),
mr2
)
elif config.model == "LineaRE":
wrh = model.wrh.weight.detach().cpu().numpy()
np.save(
os.path.join(config.save_path, "wrh"),
wrh
)
wrt = model.wrt.weight.detach().cpu().numpy()
np.save(
os.path.join(config.save_path, "wrt"),
wrt
)
elif config.model == "ComplEx":
ent_embd_im = model.ent_embd_im.weight.detach().cpu().numpy()
np.save(
os.path.join(config.save_path, "ent_embd_im"),
ent_embd_im
)
rel_embd_im = model.rel_embd_im.weight.detach().cpu().numpy()
np.save(
os.path.join(config.save_path, "rel_embd_im"),
rel_embd_im
)
elif "RotatE" in config.model:
ent_embd_im = model.ent_embd_im.weight.detach().cpu().numpy()
np.save(
os.path.join(config.save_path, "ent_embd_im"),
ent_embd_im
)
def set_logger():
log_file = os.path.join(config.save_path, "train.log")
logging.basicConfig(
format="%(asctime)s %(levelname)-5s %(message)s",
level=logging.INFO,
datefmt="%Y-%m-%d %H:%M:%S",
filename=log_file,
filemode="w"
)
console = logging.StreamHandler()
console.setLevel(logging.INFO)
formatter = logging.Formatter("%(asctime)s %(levelname)-5s %(message)s")
console.setFormatter(formatter)
logging.getLogger('').addHandler(console)
def log_metrics(mode, step, metrics):
for metric in metrics:
logging.info("%s %s at step %d: %f" % (mode, metric, step, metrics[metric]))
def train_data_iterator(train_triples, ent_num):
modes = ["head-batch", "tail-batch"]
datasets = [
DataLoader(
TrainDataset(train_triples, ent_num, config.neg_size, mode),
batch_size=config.batch_size,
shuffle=True,
num_workers=4,
collate_fn=TrainDataset.collate_fn
)
for mode in modes
]
return BidirectionalOneShotIterator(datasets[0], datasets[1])
def test_data_sets(test_triples, true_all_heads, true_all_tails, ent_num, r_tp):
modes = ["head-batch", "tail-batch"]
mode_ht = {"head-batch": true_all_heads, "tail-batch": true_all_tails}
test_dataset_list = [
DataLoader(
TestDataset(test_triples, mode_ht[mode], ent_num, mode, r_tp),
batch_size=config.test_batch_size,
num_workers=4,
collate_fn=TestDataset.collate_fn
)
for mode in modes
]
return test_dataset_list
def get_optim(optim_method, model, lr):
if optim_method == "Adam":
optimizer = torch.optim.Adam(
filter(lambda p: p.requires_grad, model.parameters()),
lr=lr
)
elif optim_method == "SGD":
optimizer = torch.optim.SGD(
filter(lambda p: p.requires_grad, model.parameters()),
lr=lr
)
else:
raise ValueError("optimizer %s not supported" % optim_method)
return optimizer
def train_step(model, optimizer, data):
model.train()
optimizer.zero_grad()
pos_sample, neg_sample, weight, mode = data
pos_sample = pos_sample.cuda()
neg_sample = neg_sample.cuda()
weight = weight.cuda()
pos_score = model(pos_sample)
neg_score = model(pos_sample, neg_sample, mode)
# neg_score = (func.softmax(-neg_score * config.alpha, dim=-1).detach()
# * func.softplus(-neg_score, beta=config.beta)).sum(dim=-1)
neg_score = func.softplus(-neg_score, beta=config.beta)
adv = neg_score.detach()
neg_score = torch.sum(adv * neg_score, dim=-1) / torch.sum(adv, dim=-1)
pos_score = pos_score.squeeze(dim=-1)
pos_score = func.softplus(pos_score, beta=config.beta)
if config.uni_weight:
pos_sample_loss = pos_score.mean()
neg_sample_loss = neg_score.mean()
else:
pos_sample_loss = (weight * pos_score).sum() / weight.sum()
neg_sample_loss = (weight * neg_score).sum() / weight.sum()
loss = (pos_sample_loss + neg_sample_loss) / 2
regularization_log = {}
if config.model == "TransE":
ent_reg = torch.abs(model.ent_embd.weight.norm(dim=-1) - 1).mean()
loss += ent_reg * config.regularization
regularization_log["ent_reg"] = ent_reg.item()
elif config.model == "TransH":
ent_reg = torch.relu(model.ent_embd.weight.norm(dim=-1) - 1).mean()
wr_norm_1 = torch.abs(model.wr.weight.norm(dim=-1) ** 2 - 1.0).mean()
wrr = func.relu(
(
(model.wr.weight * model.rel_embd.weight).sum(dim=-1)
/ model.rel_embd.weight.norm(dim=-1)
) ** 2
- 0.0001
).mean()
loss += wr_norm_1 * config.regularization
loss += wrr * config.regularization
regularization_log["ent_reg"] = ent_reg.item()
regularization_log["wr_norm_1"] = wr_norm_1.item()
regularization_log["wrr_reg"] = wrr.item()
elif config.model == "DistMult":
ent_reg = torch.sum(model.ent_embd.weight ** 2, dim=-1).mean()
rel_reg = torch.sum(model.rel_embd.weight ** 2, dim=-1).mean()
loss += ent_reg * config.regularization
loss += rel_reg * config.regularization
regularization_log["ent_reg"] = ent_reg.item()
regularization_log["rel_reg"] = rel_reg.item()
elif config.model == "ComplEx":
ent_reg = torch.sum(model.ent_embd.weight ** 2, dim=-1).mean()
rel_reg = torch.sum(model.rel_embd.weight ** 2, dim=-1).mean()
ent_im_reg = torch.sum(model.ent_embd_im.weight ** 2, dim=-1).mean()
rel_im_reg = torch.sum(model.rel_embd_im.weight ** 2, dim=-1).mean()
loss += ent_reg * config.regularization
loss += rel_reg * config.regularization
loss += ent_im_reg * config.regularization
loss += rel_im_reg * config.regularization
regularization_log["ent_reg"] = ent_reg.item()
regularization_log["rel_reg"] = rel_reg.item()
regularization_log["ent_im_reg"] = ent_im_reg.item()
regularization_log["rel_im_reg"] = rel_im_reg.item()
elif config.model == "TransD":
ent_reg = torch.sum(model.ent_embd.weight ** 2, dim=-1)
rel_reg = torch.sum(model.rel_embd.weight ** 2, dim=-1)
reg = torch.cat([ent_reg, rel_reg]).mean()
loss += reg * config.regularization
ent_p_reg = torch.sum(model.ent_p.weight ** 2, dim=-1)
rel_p_reg = torch.sum(model.rel_p.weight ** 2, dim=-1)
reg = torch.cat([ent_p_reg, rel_p_reg]).mean()
loss += reg * config.regularization
regularization_log["ent_reg"] = ent_reg.mean().item()
regularization_log["rel_reg"] = rel_reg.mean().item()
regularization_log["ent_p_reg"] = ent_p_reg.mean().item()
regularization_log["rel_p_reg"] = rel_p_reg.mean().item()
elif config.model == "TransIJ":
ent_reg = torch.sum(model.ent_embd.weight ** 2, dim=-1)
rel_reg = torch.sum(model.rel_embd.weight ** 2, dim=-1)
reg = torch.cat([ent_reg, rel_reg]).mean()
loss += reg * config.regularization
ent_p_reg = torch.sum(model.ent_p.weight ** 2, dim=-1)
reg = ent_p_reg.mean()
loss += reg * config.regularization
regularization_log["ent_reg"] = ent_reg.mean().item()
regularization_log["rel_reg"] = rel_reg.mean().item()
regularization_log["ent_p_reg"] = ent_p_reg.mean().item()
elif config.model in ["LineaRE"]:
ent_reg = torch.sum(model.ent_embd.weight ** 2, dim=-1)
rel_reg = torch.sum(model.rel_embd.weight ** 2, dim=-1)
reg = torch.cat([ent_reg, rel_reg]).mean()
loss += reg * config.regularization
regularization_log["ent_reg"] = ent_reg.mean().item()
regularization_log["rel_reg"] = rel_reg.mean().item()
loss.backward()
optimizer.step()
log = {
**regularization_log,
"pos_sample_loss": pos_sample_loss.item(),
"neg_sample_loss": neg_sample_loss.item(),
"loss": loss.item()
}
return log
def test_step(model, test_dataset_list, detail=False):
model.eval()
mode_ents = {"head-batch": 0, "tail-batch": 2}
step = 0
total_step = sum([len(dataset) for dataset in test_dataset_list])
ranks = []
mode_rtps = []
metrics = []
with torch.no_grad():
for test_dataset in test_dataset_list:
rtps = []
for pos_sample, filter_bias, mode, rel_tp in test_dataset:
pos_sample = pos_sample.cuda()
filter_bias = filter_bias.cuda()
all_scores = model(pos_sample, model.ents, mode) + filter_bias
sort = torch.argsort(all_scores)
true_ents = pos_sample[:, mode_ents[mode]].unsqueeze(dim=-1)
batch_ranks = torch.nonzero(torch.eq(sort, true_ents), as_tuple=False)
ranks.append(batch_ranks[:, 1].detach().cpu().numpy())
rtps.append(rel_tp)
if step % config.test_log_step == 0:
logging.info("Evaluating the model... (%d/%d)" % (step, total_step))
step += 1
mode_rtps.append(rtps)
ranks = np.concatenate(ranks).astype(np.float) + 1.0
reciprocal_ranks = np.reciprocal(ranks)
result = {
"MR": np.mean(ranks),
"MRR": np.mean(reciprocal_ranks),
"HITS@1": np.mean(ranks <= 1.0),
"HITS@3": np.mean(ranks <= 3.0),
"HITS@10": np.mean(ranks <= 10.0),
}
if not detail:
return result
metrics.append(result)
mode_ranks = [ranks[:ranks.size // 2], ranks[ranks.size // 2:]]
for i in range(2):
ranks = mode_ranks[i]
rtps = np.concatenate(mode_rtps[i])
for j in range(1, 5):
mm_ranks = ranks[rtps == j]
reciprocal_ranks = np.reciprocal(mm_ranks)
result = {
"MR": np.mean(mm_ranks),
"MRR": np.mean(reciprocal_ranks),
"HITS@1": np.mean(mm_ranks <= 1.0),
"HITS@3": np.mean(mm_ranks <= 3.0),
"HITS@10": np.mean(mm_ranks <= 10.0),
}
metrics.append(result)
return metrics
| 14,116 | 34.2925 | 88 | py |
LineaRE | LineaRE-master/model.py | import torch
import torch.nn as nn
from math import pi
from config import config
class Model(nn.Module):
def __init__(self, ent_num, rel_num):
super(Model, self).__init__()
self.register_buffer("gamma", torch.tensor(config.gamma))
self.register_buffer("ents", torch.arange(ent_num).unsqueeze(dim=0))
self.ent_embd = nn.Embedding(ent_num, config.ent_dim)
self.rel_embd = nn.Embedding(rel_num, config.rel_dim, max_norm=1.0)
self.init_weights()
def init_weights(self):
nn.init.xavier_uniform_(self.ent_embd.weight)
nn.init.xavier_uniform_(self.rel_embd.weight)
def get_pos_embd(self, pos_sample):
h = self.ent_embd(pos_sample[:, 0]).unsqueeze(dim=1)
r = self.rel_embd(pos_sample[:, 1]).unsqueeze(dim=1)
t = self.ent_embd(pos_sample[:, 2]).unsqueeze(dim=1)
return h, r, t
def get_neg_embd(self, neg_sample):
return self.ent_embd(neg_sample)
def forward(self, pos_sample, neg_sample=None, mode=None):
raise NotImplementedError
class TransE(Model):
def __init__(self, ent_num, rel_num):
super(TransE, self).__init__(ent_num, rel_num)
def forward(self, pos_sample, neg_sample=None, mode=None):
h, r, t = self.get_pos_embd(pos_sample)
if neg_sample is not None:
neg_embd = self.get_neg_embd(neg_sample)
if mode == "head-batch":
score = neg_embd + (r - t)
elif mode == "tail-batch":
score = (h + r) - neg_embd
else:
raise ValueError("mode %s not supported" % mode)
else:
score = h + r - t
score = torch.norm(score, p=config.norm_p, dim=-1) - self.gamma
return score
class TransH(Model):
def __init__(self, ent_num, rel_num):
super(TransH, self).__init__(ent_num, rel_num)
self.wr = nn.Embedding(rel_num, config.rel_dim)
nn.init.xavier_uniform_(self.wr.weight)
def forward(self, pos_sample, neg_sample=None, mode=None):
h, r, t, w = self.get_pos_embd(pos_sample)
if neg_sample is not None:
neg_embd = self.get_neg_embd(neg_sample)
wr_neg = (w * neg_embd).sum(dim=-1, keepdim=True)
wr_neg_wr = wr_neg * w
if mode == "head-batch":
wr_t = (w * t).sum(dim=-1, keepdim=True)
wr_t_wr = wr_t * w
score = (neg_embd - wr_neg_wr) + (r - (t - wr_t_wr))
elif mode == "tail-batch":
wr_h = (w * h).sum(dim=-1, keepdim=True)
wr_h_wr = wr_h * w
score = ((h - wr_h_wr) + r) - (neg_embd - wr_neg_wr)
else:
raise ValueError("mode %s not supported" % mode)
else:
wr_h = (w * h).sum(dim=-1, keepdim=True)
wr_h_wr = wr_h * w
wr_t = (w * t).sum(dim=-1, keepdim=True)
wr_t_wr = wr_t * w
score = (h - wr_h_wr) + r - (t - wr_t_wr)
score = torch.norm(score, p=config.norm_p, dim=-1) - self.gamma
return score
def get_pos_embd(self, pos_sample):
h, r, t = super(TransH, self).get_pos_embd(pos_sample)
w = self.wr(pos_sample[:, 1]).unsqueeze(dim=1)
return h, r, t, w
class TransR(Model):
def __init__(self, ent_num, rel_num):
super(TransR, self).__init__(ent_num, rel_num)
self.ent_embd = nn.Embedding(ent_num, config.ent_dim, max_norm=1.0)
self.rel_embd = nn.Embedding(rel_num, config.ent_dim, max_norm=1.0)
self.mr = nn.Embedding(rel_num, config.ent_dim * config.rel_dim)
nn.init.xavier_uniform_(self.mr.weight)
def forward(self, pos_sample, neg_sample=None, mode=None):
h, r, t, m = self.get_pos_embd(pos_sample)
m = m.view(-1, 1, config.rel_dim, config.ent_dim)
if neg_sample is not None:
neg_embd = self.get_neg_embd(neg_sample)
mr_neg = torch.matmul(m, neg_embd.unsqueeze(dim=-1)).squeeze(dim=-1)
if mode == "head-batch":
mr_t = torch.matmul(m, t.unsqueeze(dim=-1)).squeeze(dim=-1)
score = mr_neg + (r - mr_t)
elif mode == "tail-batch":
mr_h = torch.matmul(m, h.unsqueeze(dim=-1)).squeeze(dim=-1)
score = (mr_h + r) - mr_neg
else:
raise ValueError("mode %s not supported" % mode)
else:
mr_h = torch.matmul(m, h.unsqueeze(dim=-1)).squeeze(dim=-1)
mr_t = torch.matmul(m, t.unsqueeze(dim=-1)).squeeze(dim=-1)
score = mr_h + r - mr_t
score = torch.norm(score, p=config.norm_p, dim=-1) - self.gamma
return score
def get_pos_embd(self, pos_sample):
h, r, t = super(TransR, self).get_pos_embd(pos_sample)
m = self.mr(pos_sample[:, 1])
return h, r, t, m
class SimpleTransR(Model):
def __init__(self, ent_num, rel_num):
super(SimpleTransR, self).__init__(ent_num, rel_num)
self.ent_embd = nn.Embedding(ent_num, config.ent_dim, max_norm=1.0)
self.rel_embd = nn.Embedding(rel_num, config.rel_dim, max_norm=1.0)
self.mr = nn.Embedding(rel_num, config.rel_dim)
nn.init.xavier_uniform_(self.ent_embd.weight)
nn.init.xavier_uniform_(self.rel_embd.weight)
nn.init.xavier_uniform_(self.mr.weight)
def forward(self, pos_sample, neg_sample=None, mode=None):
h, r, t, m = self.get_pos_embd(pos_sample)
if neg_sample is not None:
neg_embd = self.get_neg_embd(neg_sample)
if mode == "head-batch":
score = m * neg_embd + (r - m * t)
elif mode == "tail-batch":
score = (m * h + r) - m * neg_embd
else:
raise ValueError("mode %s not supported" % mode)
else:
score = m * h + r - m * t
score = torch.norm(score, p=config.norm_p, dim=-1) - self.gamma
return score
def get_pos_embd(self, pos_sample):
h, r, t = super(SimpleTransR, self).get_pos_embd(pos_sample)
m = self.mr(pos_sample[:, 1]).unsqueeze(dim=1)
return h, r, t, m
class TransD(Model):
def __init__(self, ent_num, rel_num):
super(TransD, self).__init__(ent_num, rel_num)
# self.ent_embd = nn.Embedding(ent_num, config.ent_dim, max_norm=1.0)
# self.rel_embd = nn.Embedding(rel_num, config.rel_dim, max_norm=1.0)
self.ent_p = nn.Embedding(ent_num, config.ent_dim)
self.rel_p = nn.Embedding(rel_num, config.rel_dim)
# nn.init.xavier_uniform_(self.ent_embd.weight)
# nn.init.xavier_uniform_(self.rel_embd.weight)
nn.init.xavier_uniform_(self.ent_p.weight)
nn.init.xavier_uniform_(self.rel_p.weight)
@staticmethod
def ent_p_rel(ent):
if config.ent_dim == config.rel_dim:
return ent
elif config.ent_dim < config.rel_dim:
cat = torch.zeros(ent.shape[0], ent.shape[1], config.rel_dim - config.ent_dim)
if config.cuda:
cat = cat.cuda()
return torch.cat([ent, cat], dim=-1)
else:
return ent[:, :, :config.rel_dim]
def forward(self, pos_sample, neg_sample=None, mode=None):
h, r, t, hp, rp, tp = self.get_pos_embd(pos_sample)
if neg_sample is not None:
neg_embd, np = self.get_neg_embd(neg_sample)
np_neg = (np * neg_embd).sum(dim=-1, keepdim=True)
np_neg_rp = np_neg * rp
np_neg_rp_n = np_neg_rp + TransD.ent_p_rel(neg_embd)
if mode == "head-batch":
tp_t = (tp * t).sum(dim=-1, keepdim=True)
tp_t_rp = tp_t * rp
tp_t_rp_t = tp_t_rp + TransD.ent_p_rel(t)
score = np_neg_rp_n + (r - tp_t_rp_t)
elif mode == "tail-batch":
hp_h = (hp * h).sum(dim=-1, keepdim=True)
hp_h_rp = hp_h * rp
hp_h_rp_h = hp_h_rp + TransD.ent_p_rel(h)
score = (hp_h_rp_h + r) - np_neg_rp_n
else:
raise ValueError("mode %s not supported" % mode)
else:
hp_h = (hp * h).sum(dim=-1, keepdim=True)
hp_h_rp = hp_h * rp
hp_h_rp_h = hp_h_rp + TransD.ent_p_rel(h)
tp_t = (tp * t).sum(dim=-1, keepdim=True)
tp_t_rp = tp_t * rp
tp_t_rp_t = tp_t_rp + TransD.ent_p_rel(t)
score = hp_h_rp_h + r - tp_t_rp_t
score = torch.norm(score, p=config.norm_p, dim=-1) - self.gamma
return score
def get_pos_embd(self, pos_sample):
h, r, t = super(TransD, self).get_pos_embd(pos_sample)
hp = self.ent_p(pos_sample[:, 0]).unsqueeze(dim=1)
rp = self.rel_p(pos_sample[:, 1]).unsqueeze(dim=1)
tp = self.ent_p(pos_sample[:, 2]).unsqueeze(dim=1)
return h, r, t, hp, rp, tp
def get_neg_embd(self, neg_sample):
return self.ent_embd(neg_sample), self.ent_p(neg_sample)
class TransIJ(Model):
def __init__(self, ent_num, rel_num):
super(TransIJ, self).__init__(ent_num, rel_num)
self.ent_p = nn.Embedding(ent_num, config.ent_dim)
nn.init.xavier_uniform_(self.ent_p.weight)
def forward(self, pos_sample, neg_sample=None, mode=None):
h, r, t, hp, tp = self.get_pos_embd(pos_sample)
if neg_sample is not None:
neg_embd, np = self.get_neg_embd(neg_sample)
if mode == "head-batch":
h = neg_embd
hp = np
elif mode == "tail-batch":
t = neg_embd
tp = np
else:
raise ValueError("mode %s not supported" % mode)
tp_h = (tp * h).sum(dim=-1, keepdim=True)
hp_tp_h = tp_h * hp
hp_tp_h_h = hp_tp_h + h
tp_t = (tp * t).sum(dim=-1, keepdim=True)
hp_tp_t = tp_t * hp
hp_tp_t_t = hp_tp_t + t
score = hp_tp_h_h + r - hp_tp_t_t
score = torch.norm(score, p=config.norm_p, dim=-1) - self.gamma
return score
def get_pos_embd(self, pos_sample):
h, r, t = super(TransIJ, self).get_pos_embd(pos_sample)
hp = self.ent_p(pos_sample[:, 0]).unsqueeze(dim=1)
tp = self.ent_p(pos_sample[:, 2]).unsqueeze(dim=1)
return h, r, t, hp, tp
def get_neg_embd(self, neg_sample):
return self.ent_embd(neg_sample), self.ent_p(neg_sample)
class STransE(Model):
def __init__(self, ent_num, rel_num):
super(STransE, self).__init__(ent_num, rel_num)
self.mr1 = nn.Embedding(rel_num, config.ent_dim * config.rel_dim)
self.mr2 = nn.Embedding(rel_num, config.ent_dim * config.rel_dim)
nn.init.xavier_uniform_(self.mr1.weight)
nn.init.xavier_uniform_(self.mr2.weight)
def forward(self, pos_sample, neg_sample=None, mode=None):
h, r, t, m1, m2 = self.get_pos_embd(pos_sample)
m1 = m1.view(-1, 1, config.rel_dim, config.ent_dim)
m2 = m2.view(-1, 1, config.rel_dim, config.ent_dim)
if neg_sample is not None:
neg_embd = self.get_neg_embd(neg_sample)
if mode == "head-batch":
mr_neg = torch.matmul(m1, neg_embd.unsqueeze(dim=-1)).squeeze(dim=-1)
mr_t = torch.matmul(m2, t.unsqueeze(dim=-1)).squeeze(dim=-1)
score = mr_neg + (r - mr_t)
elif mode == "tail-batch":
mr_h = torch.matmul(m1, h.unsqueeze(dim=-1)).squeeze(dim=-1)
mr_neg = torch.matmul(m2, neg_embd.unsqueeze(dim=-1)).squeeze(dim=-1)
score = (mr_h + r) - mr_neg
else:
raise ValueError("mode %s not supported" % mode)
else:
mr_h = torch.matmul(m1, h.unsqueeze(dim=-1)).squeeze(dim=-1)
mr_t = torch.matmul(m2, t.unsqueeze(dim=-1)).squeeze(dim=-1)
score = mr_h + r - mr_t
score = torch.norm(score, p=config.norm_p, dim=-1) - self.gamma
return score
def get_pos_embd(self, pos_sample):
h, r, t = super(STransE, self).get_pos_embd(pos_sample)
m1 = self.mr1(pos_sample[:, 1]).unsqueeze(dim=1)
m2 = self.mr2(pos_sample[:, 1]).unsqueeze(dim=1)
return h, r, t, m1, m2
class LineaRE(Model):
def __init__(self, ent_num, rel_num):
super(LineaRE, self).__init__(ent_num, rel_num)
self.wrh = nn.Embedding(rel_num, config.rel_dim, max_norm=config.rel_dim, norm_type=1)
self.wrt = nn.Embedding(rel_num, config.rel_dim, max_norm=config.rel_dim, norm_type=1)
nn.init.zeros_(self.wrh.weight)
nn.init.zeros_(self.wrt.weight)
nn.init.xavier_uniform_(self.rel_embd.weight)
def forward(self, pos_sample, neg_sample=None, mode=None):
h, r, t, wh, wt = self.get_pos_embd(pos_sample)
if neg_sample is not None:
neg_embd = self.get_neg_embd(neg_sample)
if mode == "head-batch":
score = wh * neg_embd + (r - wt * t)
elif mode == "tail-batch":
score = (wh * h + r) - wt * neg_embd
else:
raise ValueError("mode %s not supported" % mode)
else:
score = wh * h + r - wt * t
score = torch.norm(score, p=config.norm_p, dim=-1) - self.gamma
return score
def get_pos_embd(self, pos_sample):
h, r, t = super(LineaRE, self).get_pos_embd(pos_sample)
wh = self.wrh(pos_sample[:, 1]).unsqueeze(dim=1)
wt = self.wrt(pos_sample[:, 1]).unsqueeze(dim=1)
return h, r, t, wh, wt
class DistMult(Model):
def __init__(self, ent_num, rel_num):
super(DistMult, self).__init__(ent_num, rel_num)
def forward(self, pos_sample, neg_sample=None, mode=None):
h, r, t = self.get_pos_embd(pos_sample)
if neg_sample is not None:
neg_embd = self.get_neg_embd(neg_sample)
if mode == "head-batch":
score = neg_embd * (r * t)
elif mode == "tail-batch":
score = (h * r) * neg_embd
else:
raise ValueError("mode %s not supported" % mode)
else:
score = h * r * t
return torch.sum(score, dim=-1)
class ComplEx(Model):
def __init__(self, ent_num, rel_num):
super(ComplEx, self).__init__(ent_num, rel_num)
self.ent_embd_im = nn.Embedding(ent_num, config.ent_dim)
self.rel_embd_im = nn.Embedding(rel_num, config.rel_dim)
nn.init.xavier_uniform_(self.ent_embd_im.weight)
nn.init.xavier_uniform_(self.rel_embd_im.weight)
def forward(self, pos_sample, neg_sample=None, mode=None):
h_re, r_re, t_re, h_im, r_im, t_im = self.get_pos_embd(pos_sample)
if neg_sample is not None:
neg_re, neg_im = self.get_neg_embd(neg_sample)
if mode == "head-batch":
score_re = t_re * r_re + t_im * r_im
score_im = t_re * r_im - t_im * r_re
score = neg_re * score_re - neg_im * score_im
elif mode == "tail-batch":
score_re = h_re * r_re - h_im * r_im
score_im = h_re * r_im + h_im * r_re
score = score_re * neg_re + score_im * neg_im
else:
raise ValueError("mode %s not supported" % mode)
else:
score_re = h_re * r_re - h_im * r_im
score_im = h_re * r_im + h_im * r_re
score = score_re * t_re + score_im * t_im
return torch.sum(score, dim=-1)
def get_pos_embd(self, pos_sample):
h_re, r_re, t_re = super(ComplEx, self).get_pos_embd(pos_sample)
h_im = self.ent_embd_im(pos_sample[:, 0]).unsqueeze(dim=1)
r_im = self.rel_embd_im(pos_sample[:, 1]).unsqueeze(dim=1)
t_im = self.ent_embd_im(pos_sample[:, 2]).unsqueeze(dim=1)
return h_re, r_re, t_re, h_im, r_im, t_im
def get_neg_embd(self, neg_sample):
return self.ent_embd(neg_sample), self.ent_embd_im(neg_sample)
class RotatE(Model):
def __init__(self, ent_num, rel_num):
super(RotatE, self).__init__(ent_num, rel_num)
self.ent_embd_im = nn.Embedding(ent_num, config.ent_dim)
nn.init.xavier_uniform_(self.ent_embd_im.weight)
nn.init.uniform_(self.rel_embd.weight, a=-pi, b=pi)
def forward(self, pos_sample, neg_sample=None, mode=None):
h_re, h_im, r, t_re, t_im = self.get_pos_embd(pos_sample)
rel_re = torch.cos(r)
rel_im = torch.sin(r)
if neg_sample is not None:
neg_embd_re, neg_embd_im = self.get_neg_embd(neg_sample)
if mode == "head-batch":
score_re = t_re * rel_re + t_im * rel_im
score_im = t_im * rel_re - t_re * rel_im
elif mode == "tail-batch":
score_re = h_re * rel_re - h_im * rel_im
score_im = h_re * rel_im + h_im * rel_re
else:
raise ValueError("mode %s not supported" % mode)
score_re = score_re - neg_embd_re
score_im = score_im - neg_embd_im
else:
score_re = h_re * rel_re - h_im * rel_im
score_im = h_re * rel_im + h_im * rel_re
score_re = score_re - t_re
score_im = score_im - t_im
score = torch.stack([score_re, score_im]).norm(dim=0)
score = score.sum(dim=-1) - self.gamma
return score
def get_pos_embd(self, pos_sample):
h_re, r, t_re = super(RotatE, self).get_pos_embd(pos_sample)
h_im = self.ent_embd_im(pos_sample[:, 0]).unsqueeze(1)
t_im = self.ent_embd_im(pos_sample[:, 2]).unsqueeze(1)
return h_re, h_im, r, t_re, t_im
def get_neg_embd(self, neg_sample):
return self.ent_embd(neg_sample), self.ent_embd_im(neg_sample)
| 17,770 | 40.521028 | 94 | py |
LineaRE | LineaRE-master/run.py | import logging
import os
import torch
from config import config
from model import TransE, TransH, TransD, STransE, LineaRE, DistMult, ComplEx, RotatE, SimpleTransR, TransIJ
from utils import set_logger, read_elements, read_triples, log_metrics, save_model, train_data_iterator, \
get_optim, train_step, test_step, rel_type, test_data_sets, get_true_ents
def train(model, triples, ent_num):
logging.info("Start Training...")
logging.info("batch_size = %d" % config.batch_size)
logging.info("dim = %d" % config.ent_dim)
logging.info("gamma = %f" % config.gamma)
current_lr = config.learning_rate
train_triples, valid_triples, test_triples, symmetry_test, inversion_test, composition_test, others_test = triples
all_true_triples = train_triples + valid_triples + test_triples
r_tp = rel_type(train_triples)
optimizer = get_optim("Adam", model, current_lr)
if config.init_checkpoint:
logging.info("Loading checkpoint...")
checkpoint = torch.load(os.path.join(config.save_path, "checkpoint"), map_location=torch.device("cuda:0"))
init_step = checkpoint["step"] + 1
model.load_state_dict(checkpoint["model_state_dict"])
if config.use_old_optimizer:
current_lr = checkpoint["current_lr"]
optimizer.load_state_dict(checkpoint["optimizer_state_dict"])
else:
init_step = 1
true_all_heads, true_all_tails = get_true_ents(all_true_triples)
train_iterator = train_data_iterator(train_triples, ent_num)
test_data_list = test_data_sets(valid_triples, true_all_heads, true_all_tails, ent_num, r_tp)
max_mrr = 0.0
training_logs = []
modes = ["Prediction Head", "Prediction Tail"]
rtps = ["1-1", "1-M", "M-1", "M-M"]
# Training Loop
for step in range(init_step, config.max_step + 1):
log = train_step(model, optimizer, next(train_iterator))
training_logs.append(log)
# log
if step % config.log_step == 0:
metrics = {}
for metric in training_logs[0].keys():
metrics[metric] = sum([log[metric] for log in training_logs]) / len(training_logs)
log_metrics("Training", step, metrics)
training_logs.clear()
# valid
if step % config.valid_step == 0:
logging.info("-" * 10 + "Evaluating on Valid Dataset" + "-" * 10)
metrics = test_step(model, test_data_list, True)
log_metrics("Valid", step, metrics[0])
cnt_mode_rtp = 1
for mode in modes:
for rtp in rtps:
logging.info("-" * 10 + mode + "..." + rtp + "-" * 10)
log_metrics("Valid", step, metrics[cnt_mode_rtp])
cnt_mode_rtp += 1
if metrics[0]["MRR"] >= max_mrr:
max_mrr = metrics[0]["MRR"]
save_variable_list = {
"step": step,
"current_lr": current_lr,
}
save_model(model, optimizer, save_variable_list)
if step / config.max_step in [0.2, 0.5, 0.8]:
current_lr *= 0.1
logging.info("Change learning_rate to %f at step %d" % (current_lr, step))
optimizer = get_optim("Adam", model, current_lr)
# load best state
checkpoint = torch.load(os.path.join(config.save_path, "checkpoint"))
model.load_state_dict(checkpoint["model_state_dict"])
step = checkpoint["step"]
# relation patterns
test_datasets = [symmetry_test, inversion_test, composition_test, others_test]
test_datasets_str = ["Symmetry", "Inversion", "Composition", "Other"]
for i in range(len(test_datasets)):
dataset = test_datasets[i]
dataset_str = test_datasets_str[i]
if len(dataset) == 0:
continue
test_data_list = test_data_sets(dataset, true_all_heads, true_all_tails, ent_num, r_tp)
logging.info("-" * 10 + "Evaluating on " + dataset_str + " Dataset" + "-" * 10)
metrics = test_step(model, test_data_list)
log_metrics("Valid", step, metrics)
# finally test
test_data_list = test_data_sets(test_triples, true_all_heads, true_all_tails, ent_num, r_tp)
logging.info("----------Evaluating on Test Dataset----------")
metrics = test_step(model, test_data_list, True)
log_metrics("Test", step, metrics[0])
cnt_mode_rtp = 1
for mode in modes:
for rtp in rtps:
logging.info("-" * 10 + mode + "..." + rtp + "-" * 10)
log_metrics("Test", step, metrics[cnt_mode_rtp])
cnt_mode_rtp += 1
def run():
# load data
ent2id = read_elements(os.path.join(config.data_path, "entities.dict"))
rel2id = read_elements(os.path.join(config.data_path, "relations.dict"))
ent_num = len(ent2id)
rel_num = len(rel2id)
train_triples = read_triples(os.path.join(config.data_path, "train.txt"), ent2id, rel2id)
valid_triples = read_triples(os.path.join(config.data_path, "valid.txt"), ent2id, rel2id)
test_triples = read_triples(os.path.join(config.data_path, "test.txt"), ent2id, rel2id)
symmetry_test = read_triples(os.path.join(config.data_path, "symmetry_test.txt"), ent2id, rel2id)
inversion_test = read_triples(os.path.join(config.data_path, "inversion_test.txt"), ent2id, rel2id)
composition_test = read_triples(os.path.join(config.data_path, "composition_test.txt"), ent2id, rel2id)
others_test = read_triples(os.path.join(config.data_path, "other_test.txt"), ent2id, rel2id)
logging.info("#ent_num: %d" % ent_num)
logging.info("#rel_num: %d" % rel_num)
logging.info("#train triple num: %d" % len(train_triples))
logging.info("#valid triple num: %d" % len(valid_triples))
logging.info("#test triple num: %d" % len(test_triples))
logging.info("#Model: %s" % config.model)
# 创建模型
kge_model = TransE(ent_num, rel_num)
if config.model == "TransH":
kge_model = TransH(ent_num, rel_num)
elif config.model == "TransR":
kge_model = SimpleTransR(ent_num, rel_num)
elif config.model == "TransD":
kge_model = TransD(ent_num, rel_num)
elif config.model == "STransE":
kge_model = STransE(ent_num, rel_num)
elif config.model == "LineaRE":
kge_model = LineaRE(ent_num, rel_num)
elif config.model == "DistMult":
kge_model = DistMult(ent_num, rel_num)
elif config.model == "ComplEx":
kge_model = ComplEx(ent_num, rel_num)
elif config.model == "RotatE":
kge_model = RotatE(ent_num, rel_num)
elif config.model == "TransIJ":
kge_model = TransIJ(ent_num, rel_num)
kge_model = kge_model.cuda(torch.device("cuda:0"))
logging.info("Model Parameter Configuration:")
for name, param in kge_model.named_parameters():
logging.info("Parameter %s: %s, require_grad = %s" % (name, str(param.size()), str(param.requires_grad)))
# 训练
train(
model=kge_model,
triples=(
train_triples,
valid_triples,
test_triples,
symmetry_test,
inversion_test,
composition_test,
others_test
),
ent_num=ent_num
)
if __name__ == "__main__":
set_logger()
run()
| 7,287 | 40.409091 | 118 | py |
LineaRE | LineaRE-master/new code/utils.py | import logging
from os import path
from queue import Queue
from threading import Thread
import torch
from configure import config
def set_logger():
logging.basicConfig(
format='%(asctime)s | %(levelname)s: %(message)s',
level=logging.INFO,
datefmt='%Y-%m-%d %H:%M:%S',
filename=path.join(config.save_path, 'train.log'),
filemode='w'
)
console = logging.StreamHandler()
console.setLevel(logging.INFO)
console.setFormatter(logging.Formatter('%(asctime)s | %(levelname)s: %(message)s'))
logging.getLogger().addHandler(console)
class PreDataLoader:
"""
@Author: Yuwei from https://www.zhihu.com/people/aewil-zheng, with few changes
** 包装 torch.utils.data.DataLoader, 接收该类的一个实例 loader, 启动一个线程 t, 创建一个队列 q
t 将 loader 中的数据预加载到队列 q 中, 以在模型计算时也能启动启动数据加载程序, 节省数据加载时间
** 若提供了 cuda device, 数据将直接被加载到 GPU 上
"""
def __init__(self, loader, device=None, queue_size=2):
"""
:param loader: torch.utils.data.DataLoader
:param device: torch.device('cuda' or 'cpu'), to use cpu, set None
:param queue_size: the number of samples to be preloaded
"""
self.__loader = loader
self.__device = device
self.__queue_size = queue_size
self.__load_stream = torch.cuda.Stream(device=device) \
if str(device).startswith('cuda') else None # 如果提供了 cuda device, 则创建 cuda 流
self.__queue = Queue(maxsize=self.__queue_size)
self.__idx = 0
self.__worker = Thread(target=self._load_loop)
self.__worker.setDaemon(True)
self.__worker.start()
def _load_loop(self):
""" 不断的将数据加载到队列里 """
if str(self.__device).startswith('cuda'):
logging.info(f'>>> data will be preloaded into device \'{self.__device}\'')
logging.info(f'>>> this may cost more GPU memory!!!')
# The loop that will load into the queue in the background
torch.cuda.set_device(self.__device)
while True:
for sample in self.__loader:
self.__queue.put(self._load_instance(sample))
else:
while True:
for sample in self.__loader:
self.__queue.put(sample)
def _load_instance(self, sample):
""" 将 batch 数据从 CPU 加载到 GPU 中 """
if torch.is_tensor(sample):
with torch.cuda.stream(self.__load_stream):
return sample.to(self.__device, non_blocking=True)
elif sample is None or type(sample) == str:
return sample
elif isinstance(sample, dict):
return {k: self._load_instance(v) for k, v in sample.items()}
else:
return [self._load_instance(s) for s in sample]
def __iter__(self):
self.__idx = 0
return self
def __next__(self):
# 加载线程挂了
if not self.__worker.is_alive() and self.__queue.empty():
self.__idx = 0
self.__queue.join()
self.__worker.join()
raise StopIteration
# 一个 epoch 加载完了
elif self.__idx >= len(self.__loader):
self.__idx = 0
raise StopIteration
# 下一个 batch
else:
out = self.__queue.get()
self.__queue.task_done()
self.__idx += 1
return out
def next(self):
return self.__next__()
def __len__(self):
return len(self.__loader)
@property
def sampler(self):
return self.__loader.sampler
@property
def dataset(self):
return self.__loader.dataset
| 3,067 | 25.448276 | 85 | py |
LineaRE | LineaRE-master/new code/data.py | import logging
from pathlib import Path
import numpy as np
import torch
from torch.utils.data import Dataset, DataLoader
import utils
from configure import config
def read_elements(file_path):
elements2id = {}
with open(file_path, 'r') as f:
for line in f:
e_id, e_str = line.strip().split('\t')
elements2id[e_str] = int(e_id)
return elements2id
class KG(object):
def __init__(self):
data_path = Path(config.data_path)
self.__ent2id = read_elements(data_path / 'entities.dict')
self.__rel2id = read_elements(data_path / 'relations.dict')
self.num_ents = len(self.__ent2id)
self.num_rels = len(self.__rel2id)
self.__train_triples = self._read_triples(data_path / 'train.txt')
self.__valid_triples = self._read_triples(data_path / 'valid.txt')
self.__test_triples = self._read_triples(data_path / 'test.txt')
self.__all_true_triples = self.__train_triples + self.__valid_triples + self.__test_triples
self.__test_dict = {
'test': self.__test_triples,
'valid': self.__valid_triples,
'symmetry': self._read_triples(data_path / 'symmetry_test.txt'),
'inversion': self._read_triples(data_path / 'inversion_test.txt'),
'composition': self._read_triples(data_path / 'composition_test.txt'),
'other': self._read_triples(data_path / 'other_test.txt')
}
self.__all_true_heads, self.__all_true_tails = self._get_true_ents()
self.__r_tp = self._get_rel_type()
self._logger()
def train_data_iterator(self):
return tuple(
utils.PreDataLoader(
loader=DataLoader(
dataset=dataset(self.__train_triples, self.num_ents),
batch_size=config.batch_size,
shuffle=True,
num_workers=4,
collate_fn=TrainDataset.collate_fn,
persistent_workers=True
),
device=config.device
) for dataset in [HeadDataset, TailDataset]
)
def test_data_iterator(self, test='test'):
try:
triples = self.__test_dict[test.lower()]
return [
(
DataLoader(
dataset(triples, self.num_ents, true_ents, self.__r_tp),
batch_size=config.test_batch_size,
num_workers=4,
collate_fn=TestDataset.collate_fn
),
ht
) for dataset, true_ents, ht in zip(
[TestHead, TestTail],
[self.__all_true_heads, self.__all_true_tails],
['head-batch', 'tail-batch']
)
]
except KeyError:
logging.error(f'No triple file named {test}')
exit(-1)
def _read_triples(self, file_path):
triples = []
if not file_path.is_file():
return []
with open(file_path, 'r') as f:
for line in f:
h, r, t = line.strip().split('\t')
triples.append((self.__ent2id[h], self.__rel2id[r], self.__ent2id[t]))
return triples
def _get_true_ents(self):
true_heads = {}
true_tails = {}
for h, r, t in self.__all_true_triples:
if (r, t) not in true_heads:
true_heads[(r, t)] = []
true_heads[(r, t)].append(h)
if (h, r) not in true_tails:
true_tails[(h, r)] = []
true_tails[(h, r)].append(t)
for rt in true_heads:
true_heads[rt] = np.array(true_heads[rt])
for hr in true_tails:
true_tails[hr] = np.array(true_tails[hr])
return true_heads, true_tails
def _get_rel_type(self):
count_r = {}
count_h = {}
count_t = {}
for h, r, t in self.__train_triples:
if r not in count_r:
count_r[r] = 0
count_h[r] = set()
count_t[r] = set()
count_r[r] += 1
count_h[r].add(h)
count_t[r].add(t)
r_tp = {}
for r in range(len(count_r)):
tph = count_r[r] / len(count_h[r])
hpt = count_r[r] / len(count_t[r])
if hpt < 1.5:
if tph < 1.5:
r_tp[r] = 1 # 1-1
else:
r_tp[r] = 2 # 1-M
else:
if tph < 1.5:
r_tp[r] = 3 # M-1
else:
r_tp[r] = 4 # M-M
return r_tp
def _logger(self):
logging.info(f'#ent_num: {self.num_ents:d}')
logging.info(f'#rel_num: {self.num_rels:d}')
logging.info(f'#train triple num: {len(self.__train_triples):d}')
logging.info(f'#valid triple num: {len(self.__valid_triples):d}')
logging.info(f'#test triple num: {len(self.__test_triples):d}')
class TrainDataset(Dataset):
def __init__(self, triples, num_ents):
super(TrainDataset, self).__init__()
self._triples = triples
self.__num_ents = num_ents
self.__neg_sample_size = config.neg_size + config.neg_size // 3
def __len__(self):
return len(self._triples)
def __getitem__(self, idx):
raise NotImplementedError
def _get_neg_sample(self, true_ents):
neg_list = []
neg_num = 0
while neg_num < config.neg_size: # 采 neg_size 个负样本
neg_sample = np.random.randint(self.__num_ents, size=self.__neg_sample_size)
mask = np.in1d(neg_sample, true_ents, assume_unique=True, invert=True)
neg_sample = neg_sample[mask] # 滤除 False 处的值
neg_list.append(neg_sample) # 内容为 array
neg_num += neg_sample.size
neg_sample = np.concatenate(neg_list)[:config.neg_size] # 合并, 去掉多余的
return neg_sample
@staticmethod
def collate_fn(data):
pos_sample = torch.tensor([_[0] for _ in data])
neg_sample = torch.tensor([_[1] for _ in data])
weight = torch.tensor([_[2] for _ in data])
return pos_sample, neg_sample, weight
@staticmethod
def _get_true_ents(triples, mode):
true_ents = {}
weights = {}
for triple in triples:
if mode == 'head-batch':
e2, r, e1 = triple
elif mode == 'tail-batch':
e1, r, e2 = triple
else:
raise ValueError(f'Training batch mode {mode} not supported')
if (e1, r) not in true_ents:
true_ents[(e1, r)] = []
true_ents[(e1, r)].append(e2)
for e1r, e2s in true_ents.items():
true_ents[e1r] = np.array(e2s)
weights[e1r] = 1 / (len(e2s) + config.sampling_bias) ** config.sampling_rate
return true_ents, weights
class HeadDataset(TrainDataset):
def __init__(self, triples, num_ents):
super(HeadDataset, self).__init__(triples, num_ents)
self.__true_ents, self.__weights = TrainDataset._get_true_ents(self._triples, 'head-batch')
def __getitem__(self, idx):
pos_sample = self._triples[idx]
h, r, t = pos_sample
neg_heads = self._get_neg_sample(self.__true_ents[(t, r)])
return pos_sample, neg_heads, self.__weights[(t, r)]
class TailDataset(TrainDataset):
def __init__(self, triples, num_ents):
super(TailDataset, self).__init__(triples, num_ents)
self.__true_ents, self.__weights = TrainDataset._get_true_ents(self._triples, 'tail-batch')
def __getitem__(self, idx):
pos_sample = self._triples[idx]
h, r, t = pos_sample
neg_tails = self._get_neg_sample(self.__true_ents[(h, r)])
return pos_sample, neg_tails, self.__weights[(h, r)]
class TestDataset(Dataset):
def __init__(self, triples, ent_num, true_ents, r_tp):
self._triples = triples
self._ent_num = ent_num
self._true_ents = true_ents
self._r_tp = r_tp # 关系类型
def __len__(self):
return len(self._triples)
def __getitem__(self, idx):
raise NotImplementedError
@staticmethod
def collate_fn(data):
pos_sample = torch.tensor([_[0] for _ in data])
filter_bias = torch.tensor([_[1] for _ in data])
rel_tp = np.array([_[2] for _ in data])
return pos_sample, filter_bias, rel_tp
class TestHead(TestDataset):
def __init__(self, triples, ent_num, true_ents, r_tp):
super(TestHead, self).__init__(triples, ent_num, true_ents, r_tp)
def __getitem__(self, idx):
sample = self._triples[idx]
h, r, t = sample
filter_bias = np.zeros(self._ent_num, dtype=np.float32)
filter_bias[self._true_ents[(r, t)]] = 10000.0
filter_bias[h] = 0.0
return sample, filter_bias, self._r_tp[r]
class TestTail(TestDataset):
def __init__(self, triples, ent_num, true_ents, r_tp):
super(TestTail, self).__init__(triples, ent_num, true_ents, r_tp)
def __getitem__(self, idx):
sample = self._triples[idx]
h, r, t = sample
filter_bias = np.zeros(self._ent_num, dtype=np.float32)
filter_bias[self._true_ents[(h, r)]] = 10000.0
filter_bias[t] = 0.0
return sample, filter_bias, self._r_tp[r]
class BiOneShotIterator:
def __init__(self, dataloader_head, dataloader_tail):
self.__iterator_head = self._one_shot_iterator(dataloader_head)
self.__iterator_tail = self._one_shot_iterator(dataloader_tail)
self.__step = 0
def __next__(self):
self.__step += 1
if self.__step % 2 == 0: # head 和 tail 交替返回
return next(self.__iterator_head), 'head-batch'
else:
return next(self.__iterator_tail), 'tail-batch'
def next(self):
return self.__next__()
@staticmethod
def _one_shot_iterator(dataloader):
while True:
for data in dataloader:
yield data
| 8,392 | 27.841924 | 93 | py |
LineaRE | LineaRE-master/new code/configure.py | import json
import logging
import torch
class Configure(object):
def __init__(self, config_path):
with open(config_path, 'r') as fjson:
json_config = json.load(fjson)
self.dim = json_config['dim']
self.norm_p = json_config['norm_p']
self.alpha = json_config['alpha']
self.beta = json_config['beta']
self.gamma = json_config['gamma']
self.learning_rate = json_config['learning_rate']
self.decay_rate = json_config['decay_rate']
self.batch_size = json_config['batch_size']
self.neg_size = json_config['neg_size']
self.regularization = json_config['regularization']
self.drop_rate = json_config['drop_rate']
self.test_batch_size = json_config['test_batch_size']
self.data_path = json_config['data_path']
self.save_path = json_config['save_path']
self.max_step = json_config['max_step']
self.valid_step = json_config['valid_step']
self.log_step = json_config['log_step']
self.test_log_step = json_config['test_log_step']
self.optimizer = json_config['optimizer']
self.init_checkpoint = json_config['init_checkpoint']
self.use_old_optimizer = json_config['use_old_optimizer']
self.sampling_rate = json_config['sampling_rate']
self.sampling_bias = json_config['sampling_bias']
self.device = torch.device(json_config['device'])
self.multi_gpu = json_config['multiGPU']
if self.multi_gpu:
if torch.cuda.device_count() == 0:
logging.error('no GPUs!!!\n')
exit(-1)
if torch.cuda.device_count() == 1:
logging.error('only one GPU!!!\nwill use only one GPU!!!')
def setting(self, new_path):
self.__init__(new_path)
config = Configure('config/config_FB15k.json')
| 1,634 | 33.0625 | 62 | py |
LineaRE | LineaRE-master/new code/traintest.py | import copy
import json
import logging
import pathlib
from os import path
from typing import Dict
import numpy as np
import torch
from torch import nn
from torch.optim.lr_scheduler import ExponentialLR
from configure import config
from data import KG, BiOneShotIterator
from lineare import LineaRE
class TrainTest:
def __init__(self, kg: KG):
self.__kg = kg
self.__model = LineaRE(kg.num_ents, kg.num_rels).to(config.device)
self.__cal_model = nn.DataParallel(self.__model) if config.multi_gpu else self.__model
def train(self):
logging.info('Start Training...')
data_shoter = BiOneShotIterator(*self.__kg.train_data_iterator())
optimizer, init_step, current_lr = self._get_optimizer()
scheduler = ExponentialLR(optimizer=optimizer, gamma=config.decay_rate)
max_mrr = 0.0
training_logs = []
# Training Loop
for step in range(init_step, config.max_step + 1):
log = LineaRE.train_step(self.__cal_model, optimizer, data_shoter.next())
training_logs.append(log)
# log
if step % config.log_step == 0:
metrics = {}
for metric in training_logs[0].keys():
metrics[metric] = sum([log[metric] for log in training_logs]) / len(training_logs)
self._log_metrics('Training', step, metrics)
training_logs.clear()
# valid
if step % config.valid_step == 0:
logging.info(f'---------- Evaluating on Valid Dataset ----------')
metrics = LineaRE.test_step(self.__cal_model, self.__kg.test_data_iterator(test='valid'), True)
self._log_metrics('Valid', step, metrics)
logging.info('-----------------------------------------------')
if metrics[0]['MRR'] >= max_mrr:
max_mrr = metrics[0]['MRR']
save_variable_list = {
'step': step,
'current_lr': current_lr,
}
self._save_model(optimizer, save_variable_list)
logging.info(f'Find a better model, it has been saved in \'{config.save_path}\'!')
if step / config.max_step in [0.2, 0.5, 0.8]:
scheduler.step()
current_lr *= config.decay_rate
logging.info(f'Change learning_rate to {current_lr} at step {step}')
logging.info('Training Finished!')
def test(self):
# load best model state
checkpoint = torch.load(path.join(config.save_path, 'checkpoint'))
self.__model.load_state_dict(checkpoint['model_state_dict'])
step = checkpoint['step']
# relation patterns
test_datasets_str = ['Symmetry', 'Inversion', 'Composition', 'Other']
for dataset_str in test_datasets_str:
test_data_list = self.__kg.test_data_iterator(test=dataset_str)
if len(test_datasets_str[0]) == 0:
continue
logging.info(f'---------- Evaluating on {dataset_str} Dataset ----------')
metrics = LineaRE.test_step(self.__cal_model, test_data_list)
self._log_metrics(dataset_str, step, metrics)
# finally test
test_data_list = self.__kg.test_data_iterator(test='test')
logging.info('----------Evaluating on Test Dataset----------')
metrics = LineaRE.test_step(self.__cal_model, test_data_list, True)
self._log_metrics('Test', step, metrics)
def _get_optimizer(self): # add Optimizer you wanted here
current_lr = config.learning_rate
if config.optimizer == 'Adam':
Optimizer = torch.optim.Adam
elif config.optimizer == 'Adagrad':
Optimizer = torch.optim.Adagrad
elif config.optimizer == 'SGD':
Optimizer = torch.optim.SGD
else:
raise ValueError(f'optimizer {config.optimizer} not supported')
optimizer = Optimizer(
filter(lambda p: p.requires_grad, self.__model.parameters()),
lr=current_lr
)
if config.init_checkpoint:
logging.info('Loading checkpoint...')
checkpoint = torch.load(path.join(config.save_path, 'checkpoint'), map_location=config.device)
init_step = checkpoint['step'] + 1
self.__model.load_state_dict(checkpoint['model_state_dict'])
if config.use_old_optimizer:
current_lr = checkpoint['current_lr']
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
else:
init_step = 1
return optimizer, init_step, current_lr
def _save_model(self, optimizer, save_vars):
# 保存 config
save_path = pathlib.Path(config.save_path)
config_dict = vars(copy.deepcopy(config))
del config_dict['device']
with open(save_path / 'config.json', 'w') as fjson:
json.dump(config_dict, fjson)
# 保存某些变量、模型参数、优化器参数
torch.save(
{
**save_vars,
'model_state_dict': self.__model.state_dict(),
'optimizer_state_dict': optimizer.state_dict()
},
save_path / 'checkpoint'
)
# 保存 numpy embedding
param_dict = {
'ent_embd': self.__model.ent_embd,
'rel_embd': self.__model.rel_embd,
'wrh': self.__model.wrh,
'wrt': self.__model.wrt
}
for name, param in param_dict.items():
param = param.weight.detach().cpu().numpy()
np.save(str(save_path / name), param)
@staticmethod
def _log_metrics(dataset_str, step, metrics):
def log_metrics(metrics_dict: Dict[str, float]):
for metric, value in metrics_dict.items():
logging.info(f'{dataset_str} {metric} at step {step:d}: {value:f}')
if isinstance(metrics, dict):
log_metrics(metrics)
elif isinstance(metrics, list):
log_metrics(metrics[0])
cnt_mode_rtp = 1
for mode in ('Prediction Head', 'Prediction Tail'):
for rtp in ('1-1', '1-M', 'M-1', 'M-M'):
logging.info(f'---------- {mode}... {rtp} ----------')
log_metrics(metrics[cnt_mode_rtp])
cnt_mode_rtp += 1
| 5,341 | 33.915033 | 99 | py |
LineaRE | LineaRE-master/new code/lineare.py | import logging
import numpy as np
import torch
from torch import nn
from configure import config
class LineaRE(nn.Module):
def __init__(self, num_ents, num_rels):
super(LineaRE, self).__init__()
self.register_buffer('gamma', torch.tensor(config.gamma))
self.register_buffer('ents', torch.arange(num_ents).unsqueeze(dim=0))
self.ent_embd = nn.Embedding(num_ents, config.dim, max_norm=None if config.multi_gpu else 1.0, sparse=True)
self.rel_embd = nn.Embedding(num_rels, config.dim, max_norm=None if config.multi_gpu else 1.0, sparse=True)
self.wrh = nn.Embedding(num_rels, config.dim)
self.wrt = nn.Embedding(num_rels, config.dim)
nn.init.xavier_normal_(self.ent_embd.weight)
nn.init.xavier_normal_(self.rel_embd.weight)
nn.init.zeros_(self.wrh.weight)
nn.init.zeros_(self.wrt.weight)
self.__dropout = nn.Dropout(config.drop_rate)
self.__softplus = nn.Softplus(beta=config.beta)
self.__softmax = nn.Softmax(dim=-1)
self._log_params()
def forward(self, sample, w_or_fb, ht, neg_ents=None):
if neg_ents is not None:
return self._train(sample, w_or_fb, ht, neg_ents)
else:
return self._test(sample, w_or_fb, ht)
def _train(self, sample, weight, ht, neg_ent):
h, r, t, wh, wt = self._get_pos_embd(sample)
neg_embd = self.ent_embd(neg_ent)
score = self.__dropout(wh * h + r - wt * t)
pos_score = torch.norm(score, p=config.norm_p, dim=-1) - self.gamma
pos_score = self.__softplus(torch.squeeze(pos_score, dim=-1))
if ht == 'head-batch':
score = self.__dropout(wh * neg_embd + (r - wt * t))
elif ht == 'tail-batch':
score = self.__dropout((wh * h + r) - wt * neg_embd)
else:
raise ValueError(f'mode {ht} not supported')
neg_score = self.gamma - torch.norm(score, p=config.norm_p, dim=-1)
neg_prob = self.__softmax(neg_score * config.alpha).detach()
neg_score = torch.sum(neg_prob * self.__softplus(neg_score), dim=-1)
pos_loss = weight * pos_score
neg_loss = weight * neg_score
ent_reg, rel_reg = self._regularize()
return ent_reg, rel_reg, pos_loss, neg_loss
def _test(self, sample, filter_bias, ht):
h, r, t, wh, wt = self._get_pos_embd(sample)
if ht == 'head-batch':
score = wh * self.ent_embd.weight + (r - wt * t)
elif ht == 'tail-batch':
score = (wh * h + r) - wt * self.ent_embd.weight
else:
raise ValueError(f'mode {ht} not supported')
score = torch.norm(score, p=config.norm_p, dim=-1) + filter_bias
return torch.argsort(score)
def _regularize(self):
ent_reg = torch.norm(self.ent_embd.weight, p=2, dim=-1)
rel_reg = torch.norm(self.rel_embd.weight, p=2, dim=-1)
return ent_reg, rel_reg
def _get_pos_embd(self, pos_sample):
h = self.ent_embd(pos_sample[:, 0]).unsqueeze(dim=1)
r = self.rel_embd(pos_sample[:, 1]).unsqueeze(dim=1)
t = self.ent_embd(pos_sample[:, 2]).unsqueeze(dim=1)
wh = self.wrh(pos_sample[:, 1]).unsqueeze(dim=1)
wt = self.wrt(pos_sample[:, 1]).unsqueeze(dim=1)
return h, r, t, wh, wt
def _log_params(self):
logging.info('>>> Model Parameter Configuration:')
for name, param in self.named_parameters():
logging.info(f'Parameter {name}: {str(param.size())}, require_grad = {str(param.requires_grad)}')
@staticmethod
def train_step(model, optimizer, data):
model.train()
optimizer.zero_grad()
batch, ht = data
sample, neg_ents, weight = batch
ent_reg, rel_reg, pos_loss, neg_loss = model(sample, weight, ht, neg_ents)
weight_sum = torch.sum(weight)
pos_loss = torch.sum(pos_loss) / weight_sum
neg_loss = torch.sum(neg_loss) / weight_sum
loss = (pos_loss + neg_loss) / 2
loss += torch.cat([ent_reg ** 2, rel_reg ** 2]).mean() * config.regularization
loss.backward()
optimizer.step()
log = {
'ent_reg': ent_reg.mean().item(),
'rel_reg': rel_reg.mean().item(),
'pos_sample_loss': pos_loss.item(),
'neg_sample_loss': neg_loss.item(),
'loss': loss.item()
}
return log
@staticmethod
def test_step(model, test_dataset_list, detail=False):
def get_result(ranks_):
return {
'MR': np.mean(ranks_),
'MRR': np.mean(np.reciprocal(ranks_)),
'HITS@1': np.mean(ranks_ <= 1.0),
'HITS@3': np.mean(ranks_ <= 3.0),
'HITS@10': np.mean(ranks_ <= 10.0),
}
model.eval()
mode_ents = {'head-batch': 0, 'tail-batch': 2}
step = 0
total_step = sum([len(dataset[0]) for dataset in test_dataset_list])
ranks = []
mode_rtps = []
metrics = []
with torch.no_grad():
for test_dataset, mode in test_dataset_list:
rtps = []
for pos_sample, filter_bias, rel_tp in test_dataset:
pos_sample = pos_sample.to(config.device)
filter_bias = filter_bias.to(config.device)
sort = model(pos_sample, filter_bias, mode)
true_ents = pos_sample[:, mode_ents[mode]].unsqueeze(dim=-1)
batch_ranks = torch.nonzero(torch.eq(sort, true_ents), as_tuple=False)
ranks.append(batch_ranks[:, 1].detach().cpu().numpy())
rtps.append(rel_tp)
if step % config.test_log_step == 0:
logging.info(f'Evaluating the model... ({step:d}/{total_step:d})')
step += 1
mode_rtps.append(rtps)
ranks = np.concatenate(ranks).astype(np.float32) + 1.0
result = get_result(ranks)
if not detail:
return result
metrics.append(result)
mode_ranks = [ranks[:ranks.size // 2], ranks[ranks.size // 2:]]
for i in range(2):
mode_ranks_i = mode_ranks[i]
rtps = np.concatenate(mode_rtps[i])
for j in range(1, 5):
ranks_tp = mode_ranks_i[rtps == j]
result = get_result(ranks_tp)
metrics.append(result)
return metrics
| 5,501 | 33.822785 | 109 | py |
MobileNet-SSD | MobileNet-SSD-master/gen.py | import argparse
FLAGS = None
class Generator():
def __init__(self):
self.first_prior = True
self.anchors = create_ssd_anchors()
self.last = "data"
def header(self, name):
print("name: \"%s\"" % name)
def data_deploy(self):
print(
"""input: "data"
input_shape {
dim: 1
dim: 3
dim: %d
dim: %d
}""" % (self.input_size, self.input_size))
def data_train_classifier(self):
print(
"""layer {
name: "data"
type: "Data"
top: "data"
top: "label"
data_param{
source: "%s"
backend: LMDB
batch_size: 64
}
transform_param {
crop_size: %s
mean_file: "imagenet.mean"
mirror: true
}
include: { phase: TRAIN }
}
}""")
def data_train_ssd(self):
print(
"""layer {
name: "data"
type: "AnnotatedData"
top: "data"
top: "label"
include {
phase: TRAIN
}
transform_param {
scale: 0.007843
mirror: true
mean_value: 127.5
mean_value: 127.5
mean_value: 127.5
resize_param {
prob: 1.0
resize_mode: WARP
height: %d
width: %d
interp_mode: LINEAR
interp_mode: AREA
interp_mode: NEAREST
interp_mode: CUBIC
interp_mode: LANCZOS4
}
emit_constraint {
emit_type: CENTER
}
distort_param {
brightness_prob: 0.5
brightness_delta: 32.0
contrast_prob: 0.5
contrast_lower: 0.5
contrast_upper: 1.5
hue_prob: 0.5
hue_delta: 18.0
saturation_prob: 0.5
saturation_lower: 0.5
saturation_upper: 1.5
random_order_prob: 0.0
}
expand_param {
prob: 0.5
max_expand_ratio: 4.0
}
}
data_param {
source: "%s"
batch_size: 32
backend: LMDB
}
annotated_data_param {
batch_sampler {
max_sample: 1
max_trials: 1
}
batch_sampler {
sampler {
min_scale: 0.3
max_scale: 1.0
min_aspect_ratio: 0.5
max_aspect_ratio: 2.0
}
sample_constraint {
min_jaccard_overlap: 0.1
}
max_sample: 1
max_trials: 50
}
batch_sampler {
sampler {
min_scale: 0.3
max_scale: 1.0
min_aspect_ratio: 0.5
max_aspect_ratio: 2.0
}
sample_constraint {
min_jaccard_overlap: 0.3
}
max_sample: 1
max_trials: 50
}
batch_sampler {
sampler {
min_scale: 0.3
max_scale: 1.0
min_aspect_ratio: 0.5
max_aspect_ratio: 2.0
}
sample_constraint {
min_jaccard_overlap: 0.5
}
max_sample: 1
max_trials: 50
}
batch_sampler {
sampler {
min_scale: 0.3
max_scale: 1.0
min_aspect_ratio: 0.5
max_aspect_ratio: 2.0
}
sample_constraint {
min_jaccard_overlap: 0.7
}
max_sample: 1
max_trials: 50
}
batch_sampler {
sampler {
min_scale: 0.3
max_scale: 1.0
min_aspect_ratio: 0.5
max_aspect_ratio: 2.0
}
sample_constraint {
min_jaccard_overlap: 0.9
}
max_sample: 1
max_trials: 50
}
batch_sampler {
sampler {
min_scale: 0.3
max_scale: 1.0
min_aspect_ratio: 0.5
max_aspect_ratio: 2.0
}
sample_constraint {
max_jaccard_overlap: 1.0
}
max_sample: 1
max_trials: 50
}
label_map_file: "%s"
}
}""" % (self.input_size, self.input_size, self.lmdb, self.label_map))
def data_test_ssd(self):
print(
"""layer {
name: "data"
type: "AnnotatedData"
top: "data"
top: "label"
include {
phase: TEST
}
transform_param {
scale: 0.007843
mean_value: 127.5
mean_value: 127.5
mean_value: 127.5
resize_param {
prob: 1.0
resize_mode: WARP
height: %d
width: %d
interp_mode: LINEAR
}
}
data_param {
source: "%s"
batch_size: 8
backend: LMDB
}
annotated_data_param {
batch_sampler {
}
label_map_file: "%s"
}
}""" % (self.input_size, self.input_size, self.lmdb, self.label_map))
def classifier_loss(self):
print(
"""layer {
name: "softmax"
type: "Softmax"
bottom: "%s"
top: "prob"
}
layer {
name: "accuracy"
type: "Accuracy"
bottom: "prob"
bottom: "label"
top: "accuracy"
}
layer{
name: "loss"
type: "SoftmaxWithLoss"
bottom: "%s"
bottom: "label"
loss_weight: 1
}""" % (self.last, self.last))
def ssd_predict(self):
print(
"""layer {
name: "mbox_conf_reshape"
type: "Reshape"
bottom: "mbox_conf"
top: "mbox_conf_reshape"
reshape_param {
shape {
dim: 0
dim: -1
dim: %d
}
}
}
layer {
name: "mbox_conf_softmax"
type: "Softmax"
bottom: "mbox_conf_reshape"
top: "mbox_conf_softmax"
softmax_param {
axis: 2
}
}
layer {
name: "mbox_conf_flatten"
type: "Flatten"
bottom: "mbox_conf_softmax"
top: "mbox_conf_flatten"
flatten_param {
axis: 1
}
}
layer {
name: "detection_out"
type: "DetectionOutput"
bottom: "mbox_loc"
bottom: "mbox_conf_flatten"
bottom: "mbox_priorbox"
top: "detection_out"
include {
phase: TEST
}
detection_output_param {
num_classes: %d
share_location: true
background_label_id: 0
nms_param {
nms_threshold: 0.45
top_k: 100
}
code_type: CENTER_SIZE
keep_top_k: 100
confidence_threshold: 0.25
}
}""" % (self.class_num, self.class_num))
def ssd_test(self):
print(
"""layer {
name: "mbox_conf_reshape"
type: "Reshape"
bottom: "mbox_conf"
top: "mbox_conf_reshape"
reshape_param {
shape {
dim: 0
dim: -1
dim: %d
}
}
}
layer {
name: "mbox_conf_softmax"
type: "Softmax"
bottom: "mbox_conf_reshape"
top: "mbox_conf_softmax"
softmax_param {
axis: 2
}
}
layer {
name: "mbox_conf_flatten"
type: "Flatten"
bottom: "mbox_conf_softmax"
top: "mbox_conf_flatten"
flatten_param {
axis: 1
}
}
layer {
name: "detection_out"
type: "DetectionOutput"
bottom: "mbox_loc"
bottom: "mbox_conf_flatten"
bottom: "mbox_priorbox"
top: "detection_out"
include {
phase: TEST
}
detection_output_param {
num_classes: %d
share_location: true
background_label_id: 0
nms_param {
nms_threshold: 0.45
top_k: 400
}
code_type: CENTER_SIZE
keep_top_k: 200
confidence_threshold: 0.01
}
}
layer {
name: "detection_eval"
type: "DetectionEvaluate"
bottom: "detection_out"
bottom: "label"
top: "detection_eval"
include {
phase: TEST
}
detection_evaluate_param {
num_classes: %d
background_label_id: 0
overlap_threshold: 0.5
evaluate_difficult_gt: false
}
}""" % (self.class_num, self.class_num, self.class_num))
def ssd_loss(self):
print(
"""layer {
name: "mbox_loss"
type: "MultiBoxLoss"
bottom: "mbox_loc"
bottom: "mbox_conf"
bottom: "mbox_priorbox"
bottom: "label"
top: "mbox_loss"
include {
phase: TRAIN
}
propagate_down: true
propagate_down: true
propagate_down: false
propagate_down: false
loss_param {
normalization: VALID
}
multibox_loss_param {
loc_loss_type: SMOOTH_L1
conf_loss_type: SOFTMAX
loc_weight: 1.0
num_classes: %d
share_location: true
match_type: PER_PREDICTION
overlap_threshold: 0.5
use_prior_for_matching: true
background_label_id: 0
use_difficult_gt: true
neg_pos_ratio: 3.0
neg_overlap: 0.5
code_type: CENTER_SIZE
ignore_cross_boundary_bbox: false
mining_type: MAX_NEGATIVE
}
}""" % self.class_num)
def concat_boxes(self, convs):
for layer in ["loc", "conf"]:
bottom =""
for cnv in convs:
bottom += "\n bottom: \"%s_mbox_%s_flat\"" % (cnv, layer)
print(
"""layer {
name: "mbox_%s"
type: "Concat"%s
top: "mbox_%s"
concat_param {
axis: 1
}
}""" % (layer, bottom, layer))
bottom =""
for cnv in convs:
bottom += "\n bottom: \"%s_mbox_priorbox\"" % cnv
print(
"""layer {
name: "mbox_priorbox"
type: "Concat"%s
top: "mbox_priorbox"
concat_param {
axis: 2
}
}""" % bottom)
def conv(self, name, out, kernel, stride=1, group=1, bias=False, bottom=None):
if self.stage == "deploy": #for deploy, merge bn to bias, so bias must be true
bias = True
if bottom is None:
bottom = self.last
padstr = ""
if kernel > 1:
padstr = "\n pad: %d" % (kernel / 2)
groupstr = ""
if group > 1:
groupstr = "\n group: %d\n engine: CAFFE" % group
stridestr = ""
if stride > 1:
stridestr = "\n stride: %d" % stride
bias_lr_mult = ""
bias_filler = ""
if bias == True:
bias_filler = """
bias_filler {
type: "constant"
value: 0.0
}"""
bias_lr_mult = """
param {
lr_mult: 2.0
decay_mult: 0.0
}"""
biasstr = ""
if bias == False:
biasstr = "\n bias_term: false"
print(
"""layer {
name: "%s"
type: "Convolution"
bottom: "%s"
top: "%s"
param {
lr_mult: 1.0
decay_mult: 1.0
}%s
convolution_param {
num_output: %d%s%s
kernel_size: %d%s%s
weight_filler {
type: "msra"
}%s
}
}""" % (name, bottom, name, bias_lr_mult, out, biasstr, padstr, kernel, stridestr, groupstr, bias_filler))
self.last = name
def bn(self, name):
if self.stage == "deploy": #deploy does not need bn, you can use merge_bn.py to generate a new caffemodel
return
print(
"""layer {
name: "%s/bn"
type: "BatchNorm"
bottom: "%s"
top: "%s"
param {
lr_mult: 0
decay_mult: 0
}
param {
lr_mult: 0
decay_mult: 0
}
param {
lr_mult: 0
decay_mult: 0
}
}
layer {
name: "%s/scale"
type: "Scale"
bottom: "%s"
top: "%s"
param {
lr_mult: 1.0
decay_mult: 0.0
}
param {
lr_mult: 2.0
decay_mult: 0.0
}
scale_param {
filler {
value: 1
}
bias_term: true
bias_filler {
value: 0
}
}
}""" % (name,name,name,name,name,name))
self.last = name
def relu(self, name):
print(
"""layer {
name: "%s/relu"
type: "ReLU"
bottom: "%s"
top: "%s"
}""" % (name, name, name))
self.last
self.last = name
def conv_bn_relu(self, name, num, kernel, stride):
self.conv(name, num, kernel, stride)
self.bn(name)
self.relu(name)
def conv_bn_relu_with_factor(self, name, num, kernel, stride):
num = int(num * self.size)
self.conv(name, num, kernel, stride)
self.bn(name)
self.relu(name)
def conv_dw_pw(self, name, inp, outp, stride):
inp = int(inp * self.size)
outp = int(outp * self.size)
name1 = name + "/dw"
self.conv(name1, inp, 3, stride, inp)
self.bn(name1)
self.relu(name1)
name2 = name
self.conv(name2, outp, 1)
self.bn(name2)
self.relu(name2)
def ave_pool(self, name):
print(
"""layer {
name: "%s"
type: "Pooling"
bottom: "%s"
top: "%s"
pooling_param {
pool: AVE
global_pooling: true
}
}""" % (name, self.last, name))
self.last = name
def permute(self, name):
print(
"""layer {
name: "%s_perm"
type: "Permute"
bottom: "%s"
top: "%s_perm"
permute_param {
order: 0
order: 2
order: 3
order: 1
}
}""" % (name, name, name))
self.last = name + "_perm"
def flatten(self, name):
print(
"""layer {
name: "%s_flat"
type: "Flatten"
bottom: "%s_perm"
top: "%s_flat"
flatten_param {
axis: 1
}
}""" % (name, name, name))
self.last = name + "_flat"
def mbox_prior(self, name, min_size, max_size, aspect_ratio):
min_box = self.input_size * min_size
max_box_str = ""
aspect_ratio_str = ""
if max_size is not None:
max_box = self.input_size * max_size
max_box_str = "\n max_size: %.1f" % max_box
for ar in aspect_ratio:
aspect_ratio_str += "\n aspect_ratio: %.1f" % ar
print(
"""layer {
name: "%s_mbox_priorbox"
type: "PriorBox"
bottom: "%s"
bottom: "data"
top: "%s_mbox_priorbox"
prior_box_param {
min_size: %.1f%s%s
flip: true
clip: false
variance: 0.1
variance: 0.1
variance: 0.2
variance: 0.2
offset: 0.5
}
}""" % (name, name, name, float(min_box), max_box_str, aspect_ratio_str))
def mbox_conf(self, bottom, num):
name = bottom + "_mbox_conf"
self.conv(name, num, 1, bias=True, bottom=bottom)
self.permute(name)
self.flatten(name)
def mbox_loc(self, bottom, num):
name = bottom + "_mbox_loc"
self.conv(name, num, 1, bias=True, bottom=bottom)
self.permute(name)
self.flatten(name)
def mbox(self, bottom, num):
self.mbox_loc(bottom, num * 4)
self.mbox_conf(bottom, num * self.class_num)
min_size, max_size = self.anchors[0]
if self.first_prior:
self.mbox_prior(bottom, min_size, None, [2.0])
self.first_prior = False
else:
self.mbox_prior(bottom, min_size, max_size,[2.0,3.0])
self.anchors.pop(0)
def fc(self, name, output):
print(
"""layer {
name: "%s"
type: "InnerProduct"
bottom: "%s"
top: "%s"
param { lr_mult: 1 decay_mult: 1 }
param { lr_mult: 2 decay_mult: 0 }
inner_product_param {
num_output: %d
weight_filler { type: "msra" }
bias_filler { type: "constant" value: 0 }
}
}""" % (name, self.last, name, output))
self.last = name
def reshape(self, name, output):
print(
"""layer {
name: "%s"
type: "Reshape"
bottom: "%s"
top: "%s"
reshape_param { shape { dim: -1 dim: %s dim: 1 dim: 1 } }
}""" % ( name, self.last, name, output))
self.last = name
def generate(self, stage, gen_ssd, size, class_num):
self.class_num = class_num
self.lmdb = FLAGS.lmdb
self.label_map = FLAGS.label_map
self.stage = stage
if gen_ssd:
self.input_size = 300
else:
self.input_size = 224
self.size = size
self.class_num = class_num
if gen_ssd:
self.header("MobileNet-SSD")
else:
self.header("MobileNet")
if stage == "train":
if gen_ssd:
assert(self.lmdb is not None)
assert(self.label_map is not None)
self.data_train_ssd()
else:
assert(self.lmdb is not None)
self.data_train_classifier()
elif stage == "test":
self.data_test_ssd()
else:
self.data_deploy()
self.conv_bn_relu_with_factor("conv0", 32, 3, 2)
self.conv_dw_pw("conv1", 32, 64, 1)
self.conv_dw_pw("conv2", 64, 128, 2)
self.conv_dw_pw("conv3", 128, 128, 1)
self.conv_dw_pw("conv4", 128, 256, 2)
self.conv_dw_pw("conv5", 256, 256, 1)
self.conv_dw_pw("conv6", 256, 512, 2)
self.conv_dw_pw("conv7", 512, 512, 1)
self.conv_dw_pw("conv8", 512, 512, 1)
self.conv_dw_pw("conv9", 512, 512, 1)
self.conv_dw_pw("conv10",512, 512, 1)
self.conv_dw_pw("conv11",512, 512, 1)
self.conv_dw_pw("conv12",512, 1024, 2)
self.conv_dw_pw("conv13",1024, 1024, 1)
if gen_ssd is True:
self.conv_bn_relu("conv14_1", 256, 1, 1)
self.conv_bn_relu("conv14_2", 512, 3, 2)
self.conv_bn_relu("conv15_1", 128, 1, 1)
self.conv_bn_relu("conv15_2", 256, 3, 2)
self.conv_bn_relu("conv16_1", 128, 1, 1)
self.conv_bn_relu("conv16_2", 256, 3, 2)
self.conv_bn_relu("conv17_1", 64, 1, 1)
self.conv_bn_relu("conv17_2", 128, 3, 2)
self.mbox("conv11", 3)
self.mbox("conv13", 6)
self.mbox("conv14_2", 6)
self.mbox("conv15_2", 6)
self.mbox("conv16_2", 6)
self.mbox("conv17_2", 6)
self.concat_boxes(['conv11', 'conv13', 'conv14_2', 'conv15_2', 'conv16_2', 'conv17_2'])
if stage == "train":
self.ssd_loss()
elif stage == "deploy":
self.ssd_predict()
else:
self.ssd_test()
else:
self.ave_pool("pool")
self.conv("fc", class_num, 1, 1, 1, True)
if stage == "train":
self.classifier_loss()
def create_ssd_anchors(num_layers=6,
min_scale=0.2,
max_scale=0.95):
box_specs_list = []
scales = [min_scale + (max_scale - min_scale) * i / (num_layers - 1)
for i in range(num_layers)] + [1.0]
return zip(scales[:-1], scales[1:])
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument(
'-s','--stage',
type=str,
default='train',
help='The stage of prototxt, train|test|deploy.'
)
parser.add_argument(
'-d','--lmdb',
type=str,
default=None,
help='The training database'
)
parser.add_argument(
'-l','--label-map',
type=str,
default=None,
help='The label map for ssd training.'
)
parser.add_argument(
'--classifier',
action='store_true',
help='Default generate ssd, if this is set, generate classifier prototxt.'
)
parser.add_argument(
'--size',
type=float,
default=1.0,
help='The size of mobilenet channels, support 1.0, 0.75, 0.5, 0.25.'
)
parser.add_argument(
'-c', '--class-num',
type=int,
required=True,
help='Output class number, include the \'backgroud\' class. e.g. 21 for voc.'
)
FLAGS, unparsed = parser.parse_known_args()
gen = Generator()
gen.generate(FLAGS.stage, not FLAGS.classifier, FLAGS.size, FLAGS.class_num)
| 17,879 | 20.911765 | 112 | py |
MobileNet-SSD | MobileNet-SSD-master/demo.py | import numpy as np
import sys,os
import cv2
caffe_root = '/home/yaochuanqi/work/ssd/caffe/'
sys.path.insert(0, caffe_root + 'python')
import caffe
net_file= 'deploy.prototxt'
caffe_model='mobilenet_iter_73000.caffemodel'
test_dir = "images"
if not os.path.exists(caffe_model):
print(caffe_model + " does not exist")
exit()
if not os.path.exists(net_file):
print(net_file + " does not exist")
exit()
net = caffe.Net(net_file,caffe_model,caffe.TEST)
CLASSES = ('background',
'aeroplane', 'bicycle', 'bird', 'boat',
'bottle', 'bus', 'car', 'cat', 'chair',
'cow', 'diningtable', 'dog', 'horse',
'motorbike', 'person', 'pottedplant',
'sheep', 'sofa', 'train', 'tvmonitor')
def preprocess(src):
img = cv2.resize(src, (300,300))
img = img - 127.5
img = img * 0.007843
return img
def postprocess(img, out):
h = img.shape[0]
w = img.shape[1]
box = out['detection_out'][0,0,:,3:7] * np.array([w, h, w, h])
cls = out['detection_out'][0,0,:,1]
conf = out['detection_out'][0,0,:,2]
return (box.astype(np.int32), conf, cls)
def detect(imgfile):
origimg = cv2.imread(imgfile)
img = preprocess(origimg)
img = img.astype(np.float32)
img = img.transpose((2, 0, 1))
net.blobs['data'].data[...] = img
out = net.forward()
box, conf, cls = postprocess(origimg, out)
for i in range(len(box)):
p1 = (box[i][0], box[i][1])
p2 = (box[i][2], box[i][3])
cv2.rectangle(origimg, p1, p2, (0,255,0))
p3 = (max(p1[0], 15), max(p1[1], 15))
title = "%s:%.2f" % (CLASSES[int(cls[i])], conf[i])
cv2.putText(origimg, title, p3, cv2.FONT_ITALIC, 0.6, (0, 255, 0), 1)
cv2.imshow("SSD", origimg)
k = cv2.waitKey(0) & 0xff
#Exit if ESC pressed
if k == 27 : return False
return True
for f in os.listdir(test_dir):
if detect(test_dir + "/" + f) == False:
break
| 1,975 | 26.444444 | 76 | py |
MobileNet-SSD | MobileNet-SSD-master/merge_bn.py | import os
import sys
import argparse
import logging
import numpy as np
try:
caffe_root = '/home/yaochuanqi/work/caffe/'
sys.path.insert(0, caffe_root + 'python')
import caffe
except ImportError:
logging.fatal("Cannot find caffe!")
from caffe.proto import caffe_pb2
from google.protobuf import text_format
def make_parser():
parser = argparse.ArgumentParser()
parser.add_argument('--model', type=str, required=True, help='.prototxt file for inference')
parser.add_argument('--weights', type=str, required=True, help='.caffemodel file for inference')
return parser
bn_maps = {}
def find_top_after_bn(layers, name, top):
bn_maps[name] = {}
for l in layers:
if len(l.bottom) == 0:
continue
if l.bottom[0] == top and l.type == "BatchNorm":
bn_maps[name]["bn"] = l.name
top = l.top[0]
if l.bottom[0] == top and l.type == "Scale":
bn_maps[name]["scale"] = l.name
top = l.top[0]
return top
def pre_process(expected_proto, new_proto):
net_specs = caffe_pb2.NetParameter()
net_specs2 = caffe_pb2.NetParameter()
with open(expected_proto, "r") as fp:
text_format.Merge(str(fp.read()), net_specs)
net_specs2.MergeFrom(net_specs)
layers = net_specs.layer
num_layers = len(layers)
for i in range(num_layers - 1, -1, -1):
del net_specs2.layer[i]
for idx in range(num_layers):
l = layers[idx]
if l.type == "BatchNorm" or l.type == "Scale":
continue
elif l.type == "Convolution" or l.type == "Deconvolution":
top = find_top_after_bn(layers, l.name, l.top[0])
bn_maps[l.name]["type"] = l.type
layer = net_specs2.layer.add()
layer.MergeFrom(l)
layer.top[0] = top
layer.convolution_param.bias_term = True
else:
layer = net_specs2.layer.add()
layer.MergeFrom(l)
with open(new_proto, "w") as fp:
fp.write("{}".format(net_specs2))
def load_weights(net, nobn):
if sys.version_info > (3,0):
listKeys = nobn.params.keys()
else:
listKeys = nobn.params.iterkeys()
for key in listKeys:
if type(nobn.params[key]) is caffe._caffe.BlobVec:
conv = net.params[key]
if key not in bn_maps or "bn" not in bn_maps[key]:
for i, w in enumerate(conv):
nobn.params[key][i].data[...] = w.data
else:
print(key)
bn = net.params[bn_maps[key]["bn"]]
scale = net.params[bn_maps[key]["scale"]]
wt = conv[0].data
channels = 0
if bn_maps[key]["type"] == "Convolution":
channels = wt.shape[0]
elif bn_maps[key]["type"] == "Deconvolution":
channels = wt.shape[1]
else:
print("error type " + bn_maps[key]["type"])
exit(-1)
bias = np.zeros(channels)
if len(conv) > 1:
bias = conv[1].data
mean = bn[0].data
var = bn[1].data
scalef = bn[2].data
scales = scale[0].data
shift = scale[1].data
if scalef != 0:
scalef = 1. / scalef
mean = mean * scalef
var = var * scalef
rstd = 1. / np.sqrt(var + 1e-5)
if bn_maps[key]["type"] == "Convolution":
rstd1 = rstd.reshape((channels,1,1,1))
scales1 = scales.reshape((channels,1,1,1))
wt = wt * rstd1 * scales1
else:
rstd1 = rstd.reshape((1, channels,1,1))
scales1 = scales.reshape((1, channels,1,1))
wt = wt * rstd1 * scales1
bias = (bias - mean) * rstd * scales + shift
nobn.params[key][0].data[...] = wt
nobn.params[key][1].data[...] = bias
if __name__ == '__main__':
parser1 = make_parser()
args = parser1.parse_args()
pre_process(args.model, "no_bn.prototxt")
net = caffe.Net(args.model, args.weights, caffe.TEST)
net2 = caffe.Net("no_bn.prototxt", caffe.TEST)
load_weights(net, net2)
net2.save("no_bn.caffemodel")
| 4,426 | 33.317829 | 100 | py |
pyterrier_colbert | pyterrier_colbert-main/pyterrier_colbert/indexing.py | import pyterrier as pt
import os
from pyterrier_colbert.ranking import ColBERTFactory
import numpy as np
from colbert.indexing.faiss import index_faiss
from colbert.indexing.loaders import load_doclens
import os
import ujson
import random
import copy
import queue
import math
from colbert.utils.parser import Arguments
import colbert.utils.distributed as distributed
from warnings import warn
from colbert.utils.utils import create_directory
import os
import time
import torch
import ujson
import numpy as np
import itertools
import threading
import queue
from colbert.modeling.inference import ModelInference
from colbert.evaluation.loaders import load_colbert
from . import load_checkpoint
# monkeypatch to use our downloading version
import colbert.evaluation.loaders
colbert.evaluation.loaders.load_checkpoint = load_checkpoint
colbert.evaluation.loaders.load_model.__globals__['load_checkpoint'] = load_checkpoint
from colbert.utils.utils import print_message
import pickle
from colbert.indexing.index_manager import IndexManager
from warnings import warn
DEBUG=False
class CollectionEncoder():
def __init__(self, args, process_idx, num_processes):
self.args = args
self.collection = args.collection
self.process_idx = process_idx
self.num_processes = num_processes
self.iterator = self._initialize_iterator()
# Chunksize represents the maximum size of a single .pt file
assert 0.5 <= args.chunksize <= 128.0
max_bytes_per_file = args.chunksize * (1024*1024*1024)
# A document requires at max 180 * 128 * 2 bytes = 45 KB
max_bytes_per_doc = (self.args.doc_maxlen * self.args.dim * 2.0)
# Possible subset size represents the max number of documents stored in a single .pt file,
# with a min of 10k documents.
minimum_subset_size = 10_000
maximum_subset_size = max_bytes_per_file / max_bytes_per_doc
maximum_subset_size = max(minimum_subset_size, maximum_subset_size)
self.possible_subset_sizes = [int(maximum_subset_size)]
self.print_main("#> Local args.bsize =", args.bsize)
self.print_main("#> args.index_root =", args.index_root)
self.print_main(f"#> self.possible_subset_sizes = {self.possible_subset_sizes}")
self._load_model()
self.indexmgr = IndexManager(args.dim)
def _initialize_iterator(self):
return open(self.collection)
def _saver_thread(self):
for args in iter(self.saver_queue.get, None):
self._save_batch(*args)
def _load_model(self):
if isinstance(self.args.checkpoint, torch.nn.Module):
self.colbert = self.args.checkpoint
self.checkpoint = {} # this isnt used anyway, but the retriever code checks it is a dictionary
else:
assert isinstance(self.args.checkpoint, str)
self.colbert, self.checkpoint = load_colbert(self.args, do_print=(self.process_idx == 0))
if not colbert.parameters.DEVICE == torch.device("cpu"):
self.colbert = self.colbert.cuda()
self.colbert.eval()
self.inference = ModelInference(self.colbert, amp=self.args.amp)
def encode(self):
self.saver_queue = queue.Queue(maxsize=3)
thread = threading.Thread(target=self._saver_thread)
thread.start()
t0 = time.time()
local_docs_processed = 0
for batch_idx, (offset, lines, owner) in enumerate(self._batch_passages(self.iterator)):
if owner != self.process_idx:
continue
t1 = time.time()
batch = self._preprocess_batch(offset, lines)
embs, doclens = self._encode_batch(batch_idx, batch)
t2 = time.time()
self.saver_queue.put((batch_idx, embs, offset, doclens))
print(len(lines))
t3 = time.time()
local_docs_processed += len(lines)
overall_throughput = compute_throughput(local_docs_processed, t0, t3)
this_encoding_throughput = compute_throughput(len(lines), t1, t2)
this_saving_throughput = compute_throughput(len(lines), t2, t3)
self.print(f'#> Completed batch #{batch_idx} (starting at passage #{offset}) \t\t'
f'Passages/min: {overall_throughput} (overall), ',
f'{this_encoding_throughput} (this encoding), ',
f'{this_saving_throughput} (this saving)')
self.saver_queue.put(None)
self.print("#> Joining saver thread.")
thread.join()
def _batch_passages(self, fi):
"""
Must use the same seed across processes!
"""
np.random.seed(0)
offset = 0
for owner in itertools.cycle(range(self.num_processes)):
batch_size = np.random.choice(self.possible_subset_sizes)
L = [line for _, line in zip(range(batch_size), fi)]
if len(L) == 0:
break # EOF
yield (offset, L, owner)
offset += len(L)
if len(L) < batch_size:
break # EOF
self.print("[NOTE] Done with local share.")
return
def _preprocess_batch(self, offset, lines):
endpos = offset + len(lines)
batch = []
for line_idx, line in zip(range(offset, endpos), lines):
line_parts = line.strip().split('\t')
pid, passage, *other = line_parts
if len(passage) == 0 or passage.isspace():
raise ValueError("There is an empty passage at %d. Aborting... " % line_idx )
if len(other) >= 1:
title, *_ = other
passage = title + ' | ' + passage
batch.append(passage)
assert pid == 'id' or int(pid) == line_idx
return batch
def _encode_batch(self, batch_idx, batch):
with torch.no_grad():
embs = self.inference.docFromText(batch, bsize=self.args.bsize, keep_dims=False)
assert type(embs) is list
assert len(embs) == len(batch)
local_doclens = [d.size(0) for d in embs]
embs = torch.cat(embs)
return embs, local_doclens
def _save_batch(self, batch_idx, embs, offset, doclens):
start_time = time.time()
output_path = os.path.join(self.args.index_path, "{}.pt".format(batch_idx))
output_sample_path = os.path.join(self.args.index_path, "{}.sample".format(batch_idx))
doclens_path = os.path.join(self.args.index_path, 'doclens.{}.json'.format(batch_idx))
# Save the embeddings.
print(output_path)
self.indexmgr.save(embs, output_path)
self.indexmgr.save(embs[torch.randint(0, high=embs.size(0), size=(embs.size(0) // 20,))], output_sample_path)
# Save the doclens.
with open(doclens_path, 'w') as output_doclens:
ujson.dump(doclens, output_doclens)
throughput = compute_throughput(len(doclens), start_time, time.time())
self.print_main("#> Saved batch #{} to {} \t\t".format(batch_idx, output_path),
"Saving Throughput =", throughput, "passages per minute.\n")
def print(self, *args):
print_message("[" + str(self.process_idx) + "]", "\t\t", *args)
def print_main(self, *args):
if self.process_idx == 0:
self.print(*args)
def compute_throughput(size, t0, t1):
throughput = size / (t1 - t0) * 60
if throughput > 1000 * 1000:
throughput = throughput / (1000*1000)
throughput = round(throughput, 1)
return '{}M'.format(throughput)
throughput = throughput / (1000)
throughput = round(throughput, 1)
return '{}k'.format(throughput)
class Object(object):
pass
class CollectionEncoder_Generator(CollectionEncoder):
def __init__(self, *args, prepend_title=False):
super().__init__(*args)
self.prepend_title = prepend_title
def _initialize_iterator(self):
return self.args.generator
def _preprocess_batch(self, offset, lines):
endpos = offset + len(lines)
batch = []
prepend_title = self.prepend_title
for line_idx, line in zip(range(offset, endpos), lines):
pid = line["docid"]
passage = line["text"]
if prepend_title:
title = line["title"]
passage = title + ' | ' + passage
if len(passage) == 0 or passage.isspace():
raise ValueError("There is an empty passage at %d. Aborting... " % line_idx )
batch.append(passage)
return batch
class ColBERTIndexer(pt.Indexer):
def __init__(self, checkpoint, index_root, index_name, chunksize, prepend_title=False, num_docs=None, ids=True, gpu=True, mask_punctuation=False):
args = Object()
args.similarity = 'cosine'
args.dim = 128
args.query_maxlen = 32
args.doc_maxlen = 180
args.mask_punctuation = mask_punctuation
args.checkpoint = checkpoint
args.bsize = 128
args.collection = None
args.amp = False
args.index_root = index_root
args.index_name = index_name
args.chunksize = chunksize
args.rank = -1
args.index_path = os.path.join(args.index_root, args.index_name)
args.input_arguments = copy.deepcopy(args)
args.nranks, args.distributed = distributed.init(args.rank)
self.saver_queue = queue.Queue(maxsize=3)
args.partitions = 100
args.prepend_title = False
self.args = args
self.args.sample = None
self.args.slices = 1
self.ids = ids
self.prepend_title = prepend_title
self.num_docs = num_docs
self.gpu = gpu
if not gpu:
warn("Gpu disabled, YMMV")
import colbert.parameters
import colbert.evaluation.load_model
import colbert.modeling.colbert
colbert.parameters.DEVICE = colbert.evaluation.load_model.DEVICE = colbert.modeling.colbert.DEVICE = torch.device("cpu")
assert self.args.slices >= 1
assert self.args.sample is None or (0.0 < self.args.sample <1.0), self.args.sample
def ranking_factory(self, memtype="mem"):
return ColBERTFactory(
(self.colbert, self.checkpoint),
self.args.index_root,
self.args.index_name,
self.args.partitions,
memtype, gpu=self.gpu,
mask_punctuation=self.args.mask_punctuation,
dim=self.args.dim
)
def index(self, iterator):
from timeit import default_timer as timer
starttime = timer()
maxdocs = 100
#assert not os.path.exists(self.args.index_path), self.args.index_path
docnos=[]
docid=0
def convert_gen(iterator):
import pyterrier as pt
nonlocal docnos
nonlocal docid
if self.num_docs is not None:
iterator = pt.tqdm(iterator, total=self.num_docs, desc="encoding", unit="d")
for l in iterator:
l["docid"] = docid
docnos.append(l['docno'])
docid+=1
yield l
self.args.generator = convert_gen(iterator)
ceg = CollectionEncoderIds(self.args,0,1) if self.ids else CollectionEncoder_Generator(self.args,0,1)
create_directory(self.args.index_root)
create_directory(self.args.index_path)
ceg.encode()
self.colbert = ceg.colbert
self.checkpoint = ceg.checkpoint
assert os.path.exists(self.args.index_path), self.args.index_path
num_embeddings = sum(load_doclens(self.args.index_path))
print("#> num_embeddings =", num_embeddings)
import pyterrier as pt
with pt.io.autoopen(os.path.join(self.args.index_path, "docnos.pkl.gz"), "wb") as f:
pickle.dump(docnos, f)
if self.args.partitions is None:
self.args.partitions = 1 << math.ceil(math.log2(8 * math.sqrt(num_embeddings)))
warn("You did not specify --partitions!")
warn("Default computation chooses", self.args.partitions,
"partitions (for {} embeddings)".format(num_embeddings))
index_faiss(self.args)
print("#> Faiss encoding complete")
endtime = timer()
print("#> Indexing complete, Time elapsed %0.2f seconds" % (endtime - starttime))
class CollectionEncoderIds(CollectionEncoder_Generator):
def _encode_batch(self, batch_idx, batch):
with torch.no_grad():
embs, ids = self.inference.docFromText(batch, bsize=self.args.bsize, keep_dims=False, with_ids=True)
assert type(embs) is list
assert len(embs) == len(batch)
local_doclens = [d.size(0) for d in embs]
# check that tids dont have PAD tokens, and match the lengths of the documents
if DEBUG:
for idx, (doclen, tids) in enumerate(zip(local_doclens, ids)):
assert len(tids) == doclen, (idx, len(tids), doclen)
embs = torch.cat(embs)
ids = torch.cat(ids)
return embs, local_doclens, ids
def _save_batch(self, batch_idx, embs, offset, doclens, ids):
start_time = time.time()
output_path = os.path.join(self.args.index_path, "{}.pt".format(batch_idx))
output_path_ids = os.path.join(self.args.index_path, "{}.tokenids".format(batch_idx))
output_sample_path = os.path.join(self.args.index_path, "{}.sample".format(batch_idx))
doclens_path = os.path.join(self.args.index_path, 'doclens.{}.json'.format(batch_idx))
# Save the embeddings.
self.indexmgr.save(embs, output_path)
self.indexmgr.save(ids, output_path_ids)
self.indexmgr.save(embs[torch.randint(0, high=embs.size(0), size=(embs.size(0) // 20,))], output_sample_path)
# Save the doclens.
with open(doclens_path, 'w') as output_doclens:
ujson.dump(doclens, output_doclens)
throughput = compute_throughput(len(doclens), start_time, time.time())
self.print_main("#> Saved batch #{} to {} \t\t".format(batch_idx, output_path),
"Saving Throughput =", throughput, "passages per minute.\n")
def encode(self):
self.saver_queue = queue.Queue(maxsize=3)
thread = threading.Thread(target=self._saver_thread)
thread.start()
t0 = time.time()
local_docs_processed = 0
for batch_idx, (offset, lines, owner) in enumerate(self._batch_passages(self.iterator)):
if owner != self.process_idx:
continue
t1 = time.time()
batch = self._preprocess_batch(offset, lines)
embs, doclens, ids = self._encode_batch(batch_idx, batch)
if DEBUG:
assert sum(doclens) == len(ids), (batch_idx, len(doclens), len(ids))
t2 = time.time()
self.saver_queue.put((batch_idx, embs, offset, doclens, ids))
t3 = time.time()
local_docs_processed += len(lines)
overall_throughput = compute_throughput(local_docs_processed, t0, t3)
this_encoding_throughput = compute_throughput(len(lines), t1, t2)
this_saving_throughput = compute_throughput(len(lines), t2, t3)
self.print(f'#> Completed batch #{batch_idx} (starting at passage #{offset}) \t\t'
f'Passages/min: {overall_throughput} (overall), ',
f'{this_encoding_throughput} (this encoding), ',
f'{this_saving_throughput} (this saving)')
self.saver_queue.put(None)
self.print("#> Joining saver thread.")
thread.join()
def merge_indices(index_root, index_name, num, faiss=True):
import os, glob, pickle, pyterrier as pt
"""Merge num ColBERT indexes with common index_root folder filename and index_name
into a single ColBERT index (with symlinks)"""
def count_parts(src_dir):
"""Counts how many .pt files are in src_dir folder"""
return len(glob.glob1(src_dir, "*.pt"))
def merge_docnos(src_dirs, dst_dir):
"""Merge docnos.pkl.gz files in src_dirs folders into
a single docnos.pkl.gz file in dst_dir folder"""
FILENAME = "docnos.pkl.gz"
docnos = []
for src_dir in src_dirs:
with pt.io.autoopen(os.path.join(src_dir, FILENAME), "rb") as f:
docnos += pickle.load(f)
with pt.io.autoopen(os.path.join(dst_dir, FILENAME), "wb") as f:
pickle.dump(docnos, f)
def merge_colbert_files(src_dirs, dst_dir):
"""Re-count and sym-link ColBERT index files in src_dirs folders into
a unified ColBERT index in dst_dir folder"""
FILE_PATTERNS = ["%d.pt", "%d.sample", "%d.tokenids", "doclens.%d.json"]
src_sizes = [count_parts(d) for d in src_dirs]
offset = 0
for src_size, src_dir in zip(src_sizes, src_dirs):
for i in range(src_size):
for file in FILE_PATTERNS:
src_file = os.path.join(src_dir, file % i)
dst_file = os.path.join(dst_dir, file % (offset + i))
os.symlink(src_file, dst_file)
offset += src_size
def make_new_faiss(index_root, index_name, **kwargs):
import colbert.indexing.faiss
colbert.indexing.faiss.SPAN = 1
import pyterrier_colbert.indexing
from pyterrier_colbert.indexing import ColBERTIndexer
indexer = ColBERTIndexer(None, index_root, index_name, **kwargs)
indexer.args.sample = 0.001 # We resample the whole collection to avoid kernel deaths.
# The sample has shape (7874368, 128)
# Training take 1 min, everything else is disk activity (hours...)
colbert.indexing.faiss.index_faiss(indexer.args)
src_dirs = [os.path.join(index_root, f"{index_name}_{i}") for i in range(num)]
dst_dir = os.path.join(index_root, index_name)
try:
os.mkdir(dst_dir)
except FileExistsError:
pass
merge_docnos(src_dirs, dst_dir)
merge_colbert_files(src_dirs, dst_dir)
if faiss:
make_new_faiss(index_root, index_name)
| 18,554 | 36.409274 | 150 | py |
pyterrier_colbert | pyterrier_colbert-main/pyterrier_colbert/__init__.py |
#import importlib
#ranking = importlib.import_module('.' + 'indexing', package='pyterrier_colbert')
#ranking = importlib.import_module('.' + 'ranking', package='pyterrier_colbert')
import torch
from colbert.utils.utils import print_message
from collections import OrderedDict, defaultdict
def load_checkpoint(path, model, optimizer=None, do_print=True):
if do_print:
print_message("#> Loading checkpoint", path)
if path.startswith("http:") or path.startswith("https:"):
checkpoint = torch.hub.load_state_dict_from_url(path, map_location='cpu')
else:
checkpoint = torch.load(path, map_location='cpu')
state_dict = checkpoint['model_state_dict']
new_state_dict = OrderedDict()
for k, v in state_dict.items():
name = k
if k[:7] == 'module.':
name = k[7:]
new_state_dict[name] = v
checkpoint['model_state_dict'] = new_state_dict
# check for transformer version mismatch and patch address accordingly
import transformers
from packaging import version
strict = True
if version.parse(transformers.__version__).major >= 4 and 'bert.embeddings.position_ids' not in checkpoint['model_state_dict']:
strict = False
model.load_state_dict(checkpoint['model_state_dict'], strict=strict)
if optimizer:
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
if do_print:
print_message("#> checkpoint['epoch'] =", checkpoint['epoch'])
print_message("#> checkpoint['batch'] =", checkpoint['batch'])
return checkpoint
| 1,578 | 32.595745 | 131 | py |
pyterrier_colbert | pyterrier_colbert-main/pyterrier_colbert/ranking.py |
import os
import torch
import pandas as pd
import pyterrier as pt
assert pt.started(), "please run pt.init() before importing pyt_colbert"
from pyterrier import tqdm
from pyterrier.datasets import Dataset
from typing import Union, Tuple
from colbert.evaluation.load_model import load_model
from . import load_checkpoint
# monkeypatch to use our downloading version
import colbert.evaluation.loaders
colbert.evaluation.loaders.load_checkpoint = load_checkpoint
colbert.evaluation.loaders.load_model.__globals__['load_checkpoint'] = load_checkpoint
from colbert.modeling.inference import ModelInference
from colbert.evaluation.slow import slow_rerank
from colbert.indexing.loaders import get_parts, load_doclens
import colbert.modeling.colbert
from collections import defaultdict
import numpy as np
import pickle
from warnings import warn
class file_part_mmap:
def __init__(self, file_path, file_doclens, dim):
self.dim = dim
self.doclens = file_doclens
self.endpos = np.cumsum(self.doclens)
self.startpos = self.endpos - self.doclens
mmap_storage = torch.HalfStorage.from_file(file_path, False, sum(self.doclens) * self.dim)
self.mmap = torch.HalfTensor(mmap_storage).view(sum(self.doclens), self.dim)
def get_embedding(self, pid):
startpos = self.startpos[pid]
endpos = self.endpos[pid]
return self.mmap[startpos:endpos,:]
class file_part_mem:
def __init__(self, file_path, file_doclens, dim):
self.dim = dim
self.doclens = file_doclens
self.endpos = np.cumsum(self.doclens)
self.startpos = self.endpos - self.doclens
self.mmap = torch.load(file_path)
#print(self.mmap.shape)
def get_embedding(self, pid):
startpos = self.startpos[pid]
endpos = self.endpos[pid]
return self.mmap[startpos:endpos,:]
class Object(object):
pass
from typing import List
class re_ranker_mmap:
def __init__(self, index_path, args, inference, verbose = False, memtype='mmap'):
self.args = args
self.doc_maxlen = args.doc_maxlen
assert self.doc_maxlen > 0
self.inference = inference
self.dim = args.dim
self.verbose = verbose
# Every pt file gets its own list of doc lengths
self.part_doclens = load_doclens(index_path, flatten=False)
assert len(self.part_doclens) > 0, "Did not find any indices at %s" % index_path
# Local mmapped tensors with local, single file accesses
self.part_mmap : List[file_part_mmap] = re_ranker_mmap._load_parts(index_path, self.part_doclens, self.dim, memtype)
# last pid (inclusive, e.g., the -1) in each pt file
# the -1 is used in the np.searchsorted
# so if each partition has 1000 docs, the array is [999, 1999, ...]
# this helps us map from passage id to part (inclusive, explaning the -1)
self.part_pid_end_offsets = np.cumsum([len(x) for x in self.part_doclens]) - 1
self.segment_sizes = torch.LongTensor([0] + [x.mmap.shape[0] for x in self.part_mmap])
self.segment_starts = torch.cumsum(self.segment_sizes, 0)
# first pid (inclusive) in each pt file
tmp = np.cumsum([len(x) for x in self.part_doclens])
tmp[-1] = 0
self.part_pid_begin_offsets = np.roll(tmp, 1)
# [0, 1000, 2000, ...]
self.part_pid_begin_offsets
@staticmethod
def _load_parts(index_path, part_doclens, dim, memtype="mmap"):
# Every pt file is loaded and managed independently, with local pids
_, all_parts_paths, _ = get_parts(index_path)
if memtype == "mmap":
all_parts_paths = [ file.replace(".pt", ".store") for file in all_parts_paths ]
mmaps = [file_part_mmap(path, doclens, dim) for path, doclens in zip(all_parts_paths, part_doclens)]
elif memtype == "mem":
mmaps = [file_part_mem(path, doclens, dim) for path, doclens in tqdm(zip(all_parts_paths, part_doclens), total=len(all_parts_paths), desc="Loading index shards to memory", unit="shard")]
else:
assert False, "Unknown memtype %s" % memtype
return mmaps
def num_docs(self):
"""
Return number of documents in the index
"""
return sum([len(x) for x in self.part_doclens])
def get_embedding(self, pid):
# In which pt file we need to look the given pid
part_id = np.searchsorted(self.part_pid_end_offsets, pid)
# calculate the pid local to the correct pt file
local_pid = pid - self.part_pid_begin_offsets[part_id]
# identify the tensor we look for
disk_tensor = self.part_mmap[part_id].get_embedding(local_pid)
doclen = disk_tensor.shape[0]
# only here is there a memory copy from the memory mapped file
target = torch.zeros(self.doc_maxlen, self.dim)
target[:doclen, :] = disk_tensor
return target
def get_embedding_copy(self, pid, target, index):
# In which pt file we need to look the given pid
part_id = np.searchsorted(self.part_pid_end_offsets, pid)
# calculate the pid local to the correct pt file
local_pid = pid - self.part_pid_begin_offsets[part_id]
# identify the tensor we look for
disk_tensor = self.part_mmap[part_id].get_embedding(local_pid)
doclen = disk_tensor.shape[0]
# only here is there a memory copy from the memory mapped file
target[index, :doclen, :] = disk_tensor
return target
def our_rerank(self, query, pids, gpu=True):
colbert = self.args.colbert
inference = self.inference
Q = inference.queryFromText([query])
if self.verbose:
pid_iter = tqdm(pids, desc="lookups", unit="d")
else:
pid_iter = pids
D_ = torch.zeros(len(pids), self.doc_maxlen, self.dim)
for offset, pid in enumerate(pid_iter):
self.get_embedding_copy(pid, D_, offset)
if gpu:
D_ = D_.cuda()
scores = colbert.score(Q, D_).cpu()
del(D_)
return scores.tolist()
def our_rerank_batched(self, query, pids, gpu=True, batch_size=1000):
import more_itertools
if len(pids) < batch_size:
return self.our_rerank(query, pids, gpu=gpu)
allscores=[]
for group in more_itertools.chunked(pids, batch_size):
batch_scores = self.our_rerank(query, group, gpu)
allscores.extend(batch_scores)
return allscores
def our_rerank_with_embeddings(self, qembs, pids, weightsQ=None, gpu=True):
"""
input: qid,query, docid, query_tokens, query_embeddings, query_weights
output: qid, query, docid, score
"""
colbert = self.args.colbert
inference = self.inference
# default is uniform weight for all query embeddings
if weightsQ is None:
weightsQ = torch.ones(len(qembs))
# make to 3d tensor
Q = torch.unsqueeze(qembs, 0)
if gpu:
Q = Q.cuda()
if self.verbose:
pid_iter = tqdm(pids, desc="lookups", unit="d")
else:
pid_iter = pids
D_ = torch.zeros(len(pids), self.doc_maxlen, self.dim)
for offset, pid in enumerate(pid_iter):
self.get_embedding_copy(pid, D_, offset)
if gpu:
D_ = D_.cuda()
maxscoreQ = (Q @ D_.permute(0, 2, 1)).max(2).values.cpu()
scores = (weightsQ*maxscoreQ).sum(1).cpu()
return scores.tolist()
def our_rerank_with_embeddings_batched(self, qembs, pids, weightsQ=None, gpu=True, batch_size=1000):
import more_itertools
if len(pids) < batch_size:
return self.our_rerank_with_embeddings(qembs, pids, weightsQ, gpu)
allscores=[]
for group in more_itertools.chunked(pids, batch_size):
batch_scores = self.our_rerank_with_embeddings(qembs, group, weightsQ, gpu)
allscores.extend(batch_scores)
return allscores
class ColBERTModelOnlyFactory():
def __init__(self,
colbert_model : Union[str, Tuple[colbert.modeling.colbert.ColBERT, dict]], gpu=True, mask_punctuation=False, dim=128):
args = Object()
args.query_maxlen = 32
args.doc_maxlen = 180
args.dim = dim
args.bsize = 128
args.similarity = 'cosine'
args.amp = True
args.nprobe = 10
args.part_range = None
args.mask_punctuation = mask_punctuation
self.gpu = True
if not gpu:
warn("Gpu disabled, YMMV")
import colbert.parameters
import colbert.evaluation.load_model
import colbert.modeling.colbert
colbert.parameters.DEVICE = colbert.evaluation.load_model.DEVICE = colbert.modeling.colbert.DEVICE = torch.device("cpu")
self.gpu = False
if isinstance (colbert_model, str):
args.checkpoint = colbert_model
args.colbert, args.checkpoint = load_model(args)
else:
assert isinstance(colbert_model, tuple)
args.colbert, args.checkpoint = colbert_model
from colbert.modeling.colbert import ColBERT
assert isinstance(args.colbert, ColBERT)
assert isinstance(args.checkpoint, dict)
args.inference = ModelInference(args.colbert, amp=args.amp)
self.args = args
def query_encoder(self, detach=True) -> pt.Transformer:
"""
Returns a transformer that can encode queries using ColBERT's model.
input: qid, query
output: qid, query, query_embs, query_toks,
"""
def _encode_query(row):
with torch.no_grad():
Q, ids, masks = self.args.inference.queryFromText([row.query], bsize=512, with_ids=True)
if detach:
Q = Q.cpu()
return pd.Series([Q[0], ids[0]])
def row_apply(df):
if "docno" in df.columns or "docid" in df.columns:
warn("You are query encoding an R dataframe, the query will be encoded for each row")
df[["query_embs", "query_toks"]] = df.apply(_encode_query, axis=1)
return df
return pt.apply.generic(row_apply)
def text_encoder(self, detach=True, batch_size=8) -> pt.Transformer:
"""
Returns a transformer that can encode the text using ColBERT's model.
input: qid, text
output: qid, text, doc_embs, doc_toks,
"""
def chunker(seq, size):
for pos in range(0, len(seq), size):
yield seq.iloc[pos:pos + size]
def df_apply(df):
with torch.no_grad():
rtr_embs = []
rtr_toks = []
for chunk in chunker(df, batch_size):
embsD, idsD = self.args.inference.docFromText(chunk.text.tolist(), with_ids=True)
if detach:
embsD = embsD.cpu()
rtr_embs.extend([embsD[i, : ,: ] for i in range(embsD.shape[0])])
rtr_toks.extend(idsD)
df["doc_embs"] = pd.Series(rtr_embs)
df["doc_toks"] = pd.Series(rtr_toks)
return df
return pt.apply.generic(df_apply)
def explain_text(self, query : str, document : str):
"""
Provides a diagram explaining the interaction between a query and the text of a document
"""
embsD, idsD = self.args.inference.docFromText([document], with_ids=True)
return self._explain(query, embsD, idsD)
def _explain(self, query, embsD, idsD):
embsQ, idsQ, masksQ = self.args.inference.queryFromText([query], with_ids=True)
interaction = (embsQ[0] @ embsD[0].T).cpu().numpy().T
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec
tokenmap = {"[unused1]" : "[D]", "[unused0]" : "[Q]"}
fig = plt.figure(figsize=(4, 12))
gs = GridSpec(2, 1, height_ratios=[1, 20])
ax1=fig.add_subplot(gs[0])
ax2=fig.add_subplot(gs[1])
ax2.matshow(interaction, cmap=plt.cm.Blues)
qtokens = self.args.inference.query_tokenizer.tok.convert_ids_to_tokens(idsQ[0])
dtokens = self.args.inference.query_tokenizer.tok.convert_ids_to_tokens(idsD[0])
qtokens = [tokenmap[t] if t in tokenmap else t for t in qtokens]
dtokens = [tokenmap[t] if t in tokenmap else t for t in dtokens]
ax2.set_xticks(range(32), minor=False)
ax2.set_xticklabels(qtokens, rotation=90)
ax2.set_yticks(range(len(idsD[0])))
ax2.set_yticklabels(dtokens)
ax2.set_anchor("N")
contributions=[]
for i in range(32):
maxpos = np.argmax(interaction[:,i])
plt.text(i-0.25, maxpos+0.1, "X", fontsize=5)
contributions.append(interaction[maxpos,i])
from sklearn.preprocessing import minmax_scale
ax1.bar([0.5 + i for i in range(0,32)], contributions, color=plt.cm.Blues(minmax_scale(contributions, feature_range=(0.4, 1))))
ax1.set_xlim([0,32])
ax1.set_xticklabels([])
fig.tight_layout()
#fig.subplots_adjust(hspace=-0.37)
return fig
def text_scorer(self, query_encoded=False, doc_attr="text", verbose=False) -> pt.Transformer:
"""
Returns a transformer that uses ColBERT model to score the *text* of documents.
"""
#input: qid, query, docno, text
#OR
#input: qid, query, query_embs, query_toks, query_weights, docno, text
#output: qid, query, docno, score
def slow_rerank_with_qembs(args, qembs, pids, passages, gpu=True):
inference = args.inference
# make to 3d tensor
Q = torch.unsqueeze(qembs, 0)
if gpu:
Q = Q.cuda()
D_ = inference.docFromText(passages, bsize=args.bsize)
if gpu:
D_ = D_.cuda()
scores = (Q @ D_.permute(0, 2, 1)).max(2).values.sum(1)
scores = scores.sort(descending=True)
ranked = scores.indices.tolist()
ranked_scores = scores.values.tolist()
ranked_pids = [pids[position] for position in ranked]
ranked_passages = [passages[position] for position in ranked]
return list(zip(ranked_scores, ranked_pids, ranked_passages))
def _text_scorer(queries_and_docs):
groupby = queries_and_docs.groupby("qid")
rtr=[]
with torch.no_grad():
for qid, group in tqdm(groupby, total=len(groupby), unit="q") if verbose else groupby:
query = group["query"].values[0]
ranking = slow_rerank(self.args, query, group["docno"].values, group[doc_attr].values.tolist())
for rank, (score, pid, passage) in enumerate(ranking):
rtr.append([qid, query, pid, score, rank])
return pd.DataFrame(rtr, columns=["qid", "query", "docno", "score", "rank"])
# when query is encoded
def _text_scorer_qembs(queries_and_docs):
groupby = queries_and_docs.groupby("qid")
rtr=[]
with torch.no_grad():
for qid, group in tqdm(groupby, total=len(groupby), unit="q") if verbose else groupby:
qembs = group["query_embs"].values[0]
query = group["query"].values[0]
ranking = slow_rerank_with_qembs(self.args, qembs, group["docno"].values, group[doc_attr].values.tolist(), gpu=self.gpu)
for rank, (score, pid, passage) in enumerate(ranking):
rtr.append([qid, query, pid, score, rank])
return pd.DataFrame(rtr, columns=["qid", "query", "docno", "score", "rank"])
return pt.apply.generic(_text_scorer_qembs if query_encoded else _text_scorer)
def scorer(factory, add_contributions=False, add_exact_match_contribution=False, verbose=False, gpu=True) -> pt.Transformer:
"""
Calculates the ColBERT max_sim operator using previous encodings of queries and documents
input: qid, query_embs, [query_weights], docno, doc_embs
output: ditto + score, [+ contributions]
"""
import torch
import pyterrier as pt
assert pt.started(), 'PyTerrier must be started'
cuda0 = torch.device('cuda') if gpu else torch.device('cpu')
def _build_interaction(row, D):
doc_embs = row.doc_embs
doc_len = doc_embs.shape[0]
D[row.row_index, 0:doc_len, :] = doc_embs
def _build_toks(row, idsD):
doc_toks = row.doc_toks
doc_len = doc_toks.shape[0]
idsD[row.row_index, 0:doc_len] = doc_toks
def _score_query(df):
with torch.no_grad():
weightsQ = None
Q = torch.cat([df.iloc[0].query_embs])
if "query_weights" in df.columns:
weightsQ = df.iloc[0].query_weights
else:
weightsQ = torch.ones(Q.shape[0])
if gpu:
Q = Q.cuda()
weightsQ = weightsQ.cuda()
D = torch.zeros(len(df), factory.args.doc_maxlen, factory.args.dim, device=cuda0)
df['row_index'] = range(len(df))
if verbose:
pt.tqdm.pandas(desc='scorer')
df.progress_apply(lambda row: _build_interaction(row, D), axis=1)
else:
df.apply(lambda row: _build_interaction(row, D), axis=1)
maxscoreQ = (Q @ D.permute(0, 2, 1)).max(2).values
scores = (weightsQ*maxscoreQ).sum(1).cpu()
df["score"] = scores.tolist()
if add_contributions:
contributions = (Q @ D.permute(0, 2, 1)).max(1).values.cpu()
df["contributions"] = contributions.tolist()
if add_exact_match_contribution:
idsQ = torch.cat([df.iloc[0].query_toks]).unsqueeze(0)
idsD = torch.zeros(len(df), factory.args.doc_maxlen, dtype=idsQ.dtype)
df.apply(lambda row: _build_toks(row, idsD), axis=1)
# which places in the query are actual tokens, not specials such as MASKs
token_match = (idsQ != 101) & (idsQ != 102) & (idsQ != 103) & (idsQ != 1) & (idsQ != 2)
# which places in the interaction have exact matches (not [CLS])
exact_match = (idsQ.unsqueeze(1) == idsD.unsqueeze(2)) & (idsQ != 101)
# perform the interaction
interaction = (Q @ D.permute(0, 2, 1)).cpu()
weightsQ = weightsQ.unsqueeze(0).cpu()
weighted_maxsim = weightsQ*interaction.max(2).values
# mask out query embeddings that arent tokens
weighted_maxsim[:, ~token_match[0,:]] = 0
# get the sum
denominator = weighted_maxsim.sum(1)
# zero out entries that arent exact matches
interaction[~ exact_match.permute(0, 2, 1)] = 0
weighted_maxsim = weightsQ*interaction.max(2).values
# mask out query embeddings that arent tokens
weighted_maxsim[:, ~token_match[0,:]] = 0
# get the sum
numerator = weighted_maxsim.sum(1)
#df["exact_count"] = exact_match
df["exact_numer"] = numerator.tolist()
df["exact_denom"] = denominator.tolist()
df["exact_pct"] = (numerator/denominator).tolist()
return df
return pt.apply.by_query(_score_query, add_ranks=True)
class ColBERTFactory(ColBERTModelOnlyFactory):
def __init__(self,
colbert_model : Union[str, Tuple[colbert.modeling.colbert.ColBERT, dict]],
index_root : str,
index_name : str,
faiss_partitions=None,#TODO 100-
memtype = "mem",
faisstype= "mem",
**kwargs):
super().__init__(colbert_model, **kwargs)
self.verbose = False
self._faissnn = None
self.index_root = index_root
self.index_name = index_name
self.numdocs = -1
if index_root is None or index_name is None:
warn("No index_root and index_name specified - no index ranking possible")
else:
self.index_path = os.path.join(index_root, index_name)
docnos_file = os.path.join(self.index_path, "docnos.pkl.gz")
if os.path.exists(docnos_file):
with pt.io.autoopen(docnos_file, "rb") as f:
self.docid2docno = pickle.load(f)
# support reverse docno lookup in memory
self.docno2docid = { docno : docid for docid, docno in enumerate(self.docid2docno) }
self.docid_as_docno = False
self.numdocs = len(self.docid2docno)
else:
self.docid_as_docno = True
self.faiss_index_on_gpu = True
if not self.gpu:
self.faiss_index_on_gpu = False
try:
import faiss
except:
warn("Faiss not installed. You cannot do retrieval")
self.args.partitions = faiss_partitions
self.faisstype = faisstype
self.memtype = memtype
#we load this lazily
self.rrm = None
self.faiss_index = None
# allows a colbert index to be built from a dataset
def from_dataset(dataset : Union[str,Dataset],
variant : str = None,
version='latest',
**kwargs):
from pyterrier.batchretrieve import _from_dataset
#colbertfactory doesnt match quite the expectations, so we can use a wrapper fb
def _ColBERTFactoryconstruct(folder, **kwargs):
import os
index_loc = os.path.dirname(folder)
index_name = os.path.basename(folder)
checkpoint = kwargs.get('colbert_model')
del(kwargs['colbert_model'])
return ColBERTFactory(checkpoint, index_loc, index_name, **kwargs)
return _from_dataset(dataset,
variant=variant,
version=version,
clz=_ColBERTFactoryconstruct, **kwargs)
def _rrm(self) -> re_ranker_mmap:
"""
Returns an instance of the re_ranker_mmap class.
Only one is created, if necessary.
"""
if self.rrm is not None:
return self.rrm
print("Loading reranking index, memtype=%s" % self.memtype)
self.rrm = re_ranker_mmap(
self.index_path,
self.args,
self.args.inference,
verbose=self.verbose,
memtype=self.memtype)
return self.rrm
def load_index(self, embeddings=True, faiss=False):
"""
Forces the embeddigs and faiss indices to be loaded (into memory).
If memtype or faisstype are set to mmap, then the mmapping is performed instead.
"""
if embeddings:
self._rrm()
if faiss:
self._faiss_index()
def __len__(self):
if self.numdocs > -1:
return self.numdocs
return self._rrm().num_docs()
def nn_term(self, cf=True, df=False):
"""
Returns an instance of the FaissNNTerm class, which provides statistics about terms
"""
if self._faissnn is not None:
return self._faissnn
from .faiss_term_index import FaissNNTerm
#TODO accept self.args.inference as well
self._faissnn = FaissNNTerm(
self.args.colbert,
self.index_root,
self.index_name,
faiss_index = self._faiss_index(),
cf=cf, df=df, mask_punctuation=self.args.mask_punctuation)
return self._faissnn
def _faiss_index(self):
"""
Returns an instance of the Colbert FaissIndex class, which provides nearest neighbour information
"""
from colbert.indexing.faiss import get_faiss_index_name
from colbert.ranking.faiss_index import FaissIndex
if self.faiss_index is not None:
return self.faiss_index
faiss_index_path = get_faiss_index_name(self.args)
faiss_index_path = os.path.join(self.index_path, faiss_index_path)
if not os.path.exists(faiss_index_path):
raise ValueError("No faiss index found at %s" % faiss_index_path)
self.faiss_index = FaissIndex(self.index_path, faiss_index_path, self.args.nprobe, self.args.part_range, mmap=self.faisstype == 'mmap')
# ensure the faiss_index is transferred to GPU memory for speed
import faiss
if self.faiss_index_on_gpu:
self.faiss_index.faiss_index = faiss.index_cpu_to_all_gpus(self.faiss_index.faiss_index)
return self.faiss_index
def set_retrieve(self, batch=False, query_encoded=False, faiss_depth=1000, verbose=False, docnos=False) -> pt.Transformer:
"""
Performs ANN retrieval, but the retrieval forms a set - i.e. there is no score attribute. Number of documents retrieved
is indirectly controlled by the faiss_depth parameters (denoted as k' in the original ColBERT paper).
"""
#input: qid, query
#OR
#input: qid, query, query_embs, query_toks, query_weights
#output: qid, query, docid, [docno]
#OR
#output: qid, query, query_embs, query_toks, query_weights, docid, [docno]
assert not batch
faiss_index = self._faiss_index()
# this is when queries have NOT already been encoded
def _single_retrieve(queries_df):
# we know that query_encoded=False
if "query_embs" in queries_df.columns:
warn("set_retrieve() used with query_encoded=False, but query_embs column present in input. Should you use query_encoded=True?")
rtr = []
iter = queries_df.itertuples()
iter = tqdm(iter, unit="q") if verbose else iter
for row in iter:
qid = row.qid
query = row.query
with torch.no_grad():
Q, ids, masks = self.args.inference.queryFromText([query], bsize=512, with_ids=True)
Q_f = Q[0:1, :, :]
all_pids = faiss_index.retrieve(faiss_depth, Q_f, verbose=verbose)
Q_cpu = Q[0, :, :].cpu()
for passage_ids in all_pids:
if verbose:
print("qid %s retrieved docs %d" % (qid, len(passage_ids)))
for pid in passage_ids:
rtr.append([qid, query, pid, ids[0], Q_cpu])
#build the DF to return for this query
rtrDf = pd.DataFrame(rtr, columns=["qid","query",'docid','query_toks','query_embs'] )
if docnos:
rtrDf = self._add_docnos(rtrDf)
return rtrDf
# this is when queries have already been encoded
def _single_retrieve_qembs(queries_df):
rtr = []
query_weights = "query_weights" in queries_df.columns
iter = queries_df.itertuples()
iter = tqdm(iter, unit="q") if verbose else iter
for row in iter:
qid = row.qid
embs = row.query_embs
Q_f = torch.unsqueeze(embs, 0)
all_pids = faiss_index.retrieve(faiss_depth, Q_f, verbose=verbose)
for passage_ids in all_pids:
if verbose:
print("qid %s retrieved docs %d" % (qid, len(passage_ids)))
for pid in passage_ids:
if query_weights:
rtr.append([qid, row.query, pid, row.query_toks, row.query_embs, row.query_weights])
else:
rtr.append([qid, row.query, pid, row.query_toks, row.query_embs])
#build the DF to return for this query
cols = ["qid","query",'docid','query_toks','query_embs']
if query_weights:
cols.append("query_weights")
rtrDf = pd.DataFrame(rtr, columns=cols)
if docnos:
rtrDf = self._add_docnos(rtrDf)
return rtrDf
return pt.apply.generic(_single_retrieve_qembs if query_encoded else _single_retrieve)
def _add_docids(self, df):
if self.docid_as_docno:
df["docid"] = df["docno"].astype('int64')
else:
df["docid"] = df["docno"].apply(lambda docno : self.docno2docid[docno])
return df
def _add_docnos(self, df):
if self.docid_as_docno:
df["docno"] = df["docid"].astype('str')
else:
df["docno"] = df["docid"].apply(lambda docid : self.docid2docno[docid])
return df
def index_scorer(self, query_encoded=False, add_ranks=False, add_docnos=True, batch_size=10000) -> pt.Transformer:
"""
Returns a transformer that uses the ColBERT index to perform scoring of documents to queries
"""
#input: qid, query, [docno], [docid]
#OR
#input: qid, query, query_embs, query_toks, query_weights, docno], [docid]
#output: qid, query, docno, score
rrm = self._rrm()
def rrm_scorer(qid_group):
if "query_embs" in qid_group.columns:
warn("index_scorer() used with query_encoded=False, but query_embs column present in input. Should you use query_encoded=True?")
qid_group = qid_group.copy()
if "docid" not in qid_group.columns:
qid_group = self._add_docids(qid_group)
qid_group.sort_values("docid", inplace=True)
docids = qid_group["docid"].values
if batch_size > 0:
scores = rrm.our_rerank_batched(qid_group.iloc[0]["query"], docids, batch_size=batch_size, gpu=self.gpu)
else:
scores = rrm.our_rerank(qid_group.iloc[0]["query"], docids, gpu=self.gpu)
qid_group["score"] = scores
if "docno" not in qid_group.columns and add_docnos:
qid_group = self._add_docnos(qid_group)
if add_ranks:
return pt.model.add_ranks(qid_group)
return qid_group
def rrm_scorer_query_embs(qid_group):
qid_group = qid_group.copy()
if "docid" not in qid_group.columns:
qid_group = self._add_docids(qid_group)
qid_group.sort_values("docid", inplace=True)
docids = qid_group["docid"].values
weights = None
if "query_weights" in qid_group.columns:
weights = qid_group.iloc[0].query_weights
if batch_size > 0:
scores = rrm.our_rerank_with_embeddings_batched(qid_group.iloc[0]["query_embs"], docids, weights, batch_size=batch_size, gpu=self.gpu)
else:
scores = rrm.our_rerank_with_embeddings(qid_group.iloc[0]["query_embs"], docids, weights, gpu=self.gpu)
qid_group["score"] = scores
if "docno" not in qid_group.columns and add_docnos:
qid_group = self._add_docnos(qid_group)
if add_ranks:
return pt.model.add_ranks(qid_group)
return qid_group
if query_encoded:
return pt.apply.by_query(rrm_scorer_query_embs)
return pt.apply.by_query(rrm_scorer)
def get_embeddings_by_token(self, tokenid, flatten=True, sample=None) -> Union[torch.TensorType, List[torch.TensorType]]:
"""
Returns all embeddings for a given tokenid. Specifying a sample fraction results in the embeddings being sampled.
"""
import torch
from typing import List
def partition(tensor : torch.Tensor, offsets : torch.Tensor) -> List[torch.Tensor]:
num_shards = offsets.shape[0]
positions = torch.bucketize(tensor, offsets[1:])
rtr = [tensor[positions == shard_id] for shard_id in range(num_shards)]
return rtr
nn_term = self.nn_term()
rrm = self._rrm()
# global positions of this tokenid in the entire index
offsets = (nn_term.emb2tid == tokenid).nonzero()
# apply sampling if requested
if sample is not None:
offsets = offsets[self.rng.integers(0, len(offsets), int(sample * len(offsets)))]
# get offsets partitioned by index shard
partitioned_offsets = partition(offsets, self.segment_starts)
# get the requested embeddings
all_tensors = [ rrm.part_mmap[shard].mmap[shard_portion - self.segment_starts[shard]] for shard, shard_portion in enumerate(partitioned_offsets) if shard_portion.shape[0] > 0 ]
# if requested, make a single tensor - involves a further copy
if flatten:
all_tensors = torch.cat(all_tensors).squeeze()
return all_tensors
def end_to_end(self) -> pt.Transformer:
"""
Returns a transformer composition that uses a ColBERT FAISS index to retrieve documents, followed by a ColBERT index
to perform accurate scoring of the retrieved documents. Equivalent to `colbertfactory.set_retrieve() >> colbertfactory.index_scorer()`.
"""
#input: qid, query,
#output: qid, query, docno, score
return self.set_retrieve() >> self.index_scorer(query_encoded=True)
def ann_retrieve_score(self, batch=False, query_encoded=False, faiss_depth=1000, verbose=False, maxsim=True, add_ranks=True, add_docnos=True, num_qembs_hint=32) -> pt.Transformer:
"""
Like set_retrieve(), uses the ColBERT FAISS index to retrieve documents, but scores them using the maxsim on the approximate
(quantised) nearest neighbour scores.
This method was first proposed in our CIKM 2021 paper.
Parameters:
- batch(bool): whether to process all queries at once. True not currently supported.
- query_encoded(bool): whether to apply the ColBERT model to encode the queries. Defaults to false.
- faiss_depth(int): How many passage embeddings to retrieve for each query embedding, denoted as k' in the ColBERT paper. Defaults to 1000, as per the ColBERT paper.
- verbose(bool): Display tqdm progress bar during retrieval
- maxsim(bool): Whether to use approx maxsim (True) or approx sumsim (False). See our CIKM 2021 paper for more details. Default is True.
- add_ranks(bool): Whether to use add the rank column, to allow rank cutoffs to be applied. Default is True. Response time will be enhanced if False.
- add_docnos(bool): Whether to use add the docno column. Default is True. Response time will be enhanced if False.
Reference:
C. Macdonald, N. Tonellotto. On Approximate Nearest Neighbour Selection for Multi-Stage Dense Retrieval
In Proceedings of ICTIR CIKM.
"""
#input: qid, query
#OR
#input: qid, query, query_embs, query_toks, query_weights
#output: qid, query, docid, [docno], score, [rank]
#OR
#output: qid, query, query_embs, query_toks, query_weights, docid, [docno], score, [rank]
assert not batch, "batching not supported yet"
assert hasattr(self._faiss_index(), 'faiss_index'), "multi index support removed"
# all_scores, all_embedding_ids = self._faiss_index().search(Q_cpu_numpy, faiss_depth, verbose=verbose)
# pids = np.searchsorted(self.faiss_index.doc_offsets, embedding_ids, side='right') - 1
assert maxsim, "only maxsim supported now."
# this is a big malloc, sized for the number of docs in the collection
# for this reason, we reuse it across queries. All used values are reset
# to zero afer use.
import numpy as np
score_buffer = np.zeros( (len(self), num_qembs_hint ) )
def _single_retrieve(queries_df):
rtr = []
weights_set = "query_weights" in queries_df.columns
iter = queries_df.itertuples()
iter = tqdm(iter, unit="q") if verbose else iter
for row in iter:
qid = row.qid
if query_encoded:
embs = row.query_embs
qtoks = row.query_toks
ids = np.expand_dims(qtoks, axis=0)
Q_cpu = embs.cpu()
Q_cpu_numpy = embs.float().numpy()
#NB: ids is 2D
qweights = row.query_weights.unsqueeze(0) if weights_set else torch.ones(ids.shape)
else:
if "query_embs" in queries_df.columns:
warn("ann_retrieve_score() used with query_encoded=False, but query_embs column present in input. Should you use query_encoded=True?")
with torch.no_grad():
Q, ids, masks = self.args.inference.queryFromText([row.query], bsize=512, with_ids=True)
Q_f = Q[0:1, :, : ]
Q_cpu = Q[0, :, :].cpu()
Q_cpu_numpy = Q_cpu.float().numpy()
#NB: ids is 2D
qweights = torch.ones(ids.shape)
all_scores, all_embedding_ids = self._faiss_index().faiss_index.search(Q_cpu_numpy, faiss_depth)
nonlocal score_buffer
# we reuse this buffer, but it has to be big enough for expanded queries
if score_buffer.shape[1] < Q_cpu_numpy.shape[0]:
score_buffer = np.zeros( (len(self), Q_cpu_numpy.shape[0] ) )
pids, final_scores = _approx_maxsim_numpy(all_scores, all_embedding_ids, self.faiss_index.emb2pid.numpy(), qweights[0].numpy(), score_buffer)
for offset in range(pids.shape[0]):
rtr.append([qid, row.query, pids[offset], final_scores[offset], ids[0], Q_cpu, qweights[0]])
rtr = pd.DataFrame(rtr, columns=["qid","query",'docid', 'score','query_toks','query_embs', 'query_weights'])
if add_docnos:
rtr = self._add_docnos(rtr)
if add_ranks:
rtr = pt.model.add_ranks(rtr)
return rtr
t = pt.apply.by_query(_single_retrieve, add_ranks=False, verbose=verbose)
import types
def __reduce_ex__(t2, proto):
kwargs = { 'batch':batch, 'query_encoded': query_encoded, 'faiss_depth' : faiss_depth, 'maxsim': maxsim}
return (
ann_retrieve_score,
#self is the factory, and it will be serialised using its own __reduce_ex__ method
(self, [], kwargs),
None
)
t.__reduce_ex__ = types.MethodType(__reduce_ex__, t)
t.__getstate__ = types.MethodType(lambda t2 : None, t)
return t
def fetch_index_encodings(factory, verbose=False, ids=False) -> pt.Transformer:
"""
New encoder that gets embeddings from rrm and stores into doc_embs column.
If ids is True, then an additional doc_toks column is also added. This requires
a Faiss NN term index data structure, i.e. indexing should have ids=True set.
input: docid, ...
output: ditto + doc_embs [+ doc_toks]
"""
def _get_embs(df):
rrm = factory._rrm() # _rrm() instead of rrm because we need to check it has already been loaded.
if verbose:
import pyterrier as pt
pt.tqdm.pandas(desc="fetch_index_encodings")
df["doc_embs"] = df.docid.progress_apply(rrm.get_embedding)
else:
df["doc_embs"] = df.docid.apply(rrm.get_embedding)
return df
def _get_tok_ids(df):
fnt = factory.nn_term(False)
def _get_toks(pid):
end = fnt.end_offsets[pid]
start = end - fnt.doclens[pid]
return fnt.emb2tid[start:end].clone()
if verbose:
import pyterrier as pt
pt.tqdm.pandas()
df["doc_toks"] = df.docid.progress_apply(_get_toks)
else:
df["doc_toks"] = df.docid.apply(_get_toks)
return df
rtr = pt.apply.by_query(_get_embs, add_ranks=False)
if ids:
rtr = rtr >> pt.apply.by_query(_get_tok_ids, add_ranks=False)
return rtr
def prf(pytcolbert, rerank, fb_docs=3, fb_embs=10, beta=1.0, k=24) -> pt.Transformer:
"""
Returns a pipeline for ColBERT PRF, either as a ranker, or a re-ranker. Final ranking is cutoff at 1000 docs.
Parameters:
- rerank(bool): Whether to rerank the initial documents, or to perform a new set retrieve to gather new documents.
- fb_docs(int): Number of passages to use as feedback. Defaults to 3.
- k(int): Number of clusters to apply on the embeddings of the top K documents. Defaults to 24.
- fb_embs(int): Number of expansion embeddings to add to the query. Defaults to 10.
- beta(float): Weight of the new embeddings compared to the original emebddings. Defaults to 1.0.
Reference:
X. Wang, C. Macdonald, N. Tonellotto, I. Ounis. Pseudo-Relevance Feedback for Multiple Representation Dense Retrieval.
In Proceedings of ICTIR 2021.
"""
#input: qid, query,
#output: qid, query, query_embs, query_toks, query_weights, docno, rank, score
dense_e2e = pytcolbert.set_retrieve() >> pytcolbert.index_scorer(query_encoded=True, add_ranks=True, batch_size=10000)
if rerank:
prf_pipe = (
dense_e2e
>> ColbertPRF(pytcolbert, k=k, fb_docs=fb_docs, fb_embs=fb_embs, beta=beta, return_docs=True)
>> (pytcolbert.index_scorer(query_encoded=True, add_ranks=True, batch_size=5000) %1000)
)
else:
prf_pipe = (
dense_e2e
>> ColbertPRF(pytcolbert, k=k, fb_docs=fb_docs, fb_embs=fb_embs, beta=beta, return_docs=False)
>> pytcolbert.set_retrieve(query_encoded=True)
>> (pytcolbert.index_scorer(query_encoded=True, add_ranks=True, batch_size=5000) % 1000)
)
return prf_pipe
def explain_doc(self, query : str, doc : Union[str,int]):
"""
Provides a diagram explaining the interaction between a query and a given docno
"""
if isinstance(doc,str):
pid = self.docno2docid[doc]
elif isinstance(doc,int):
pid = doc
else:
raise ValueError("Expected docno(str) or docid(int)")
embsD = self._rrm().get_embedding(pid)
idsD = self.nn_term().get_tokens_for_doc(pid)
return self._explain(query, embsD, idsD)
import pandas as pd
class ColbertPRF(pt.Transformer):
def __init__(self, pytcfactory, k, fb_embs, beta=1, r = 42, return_docs = False, fb_docs=10, *args, **kwargs):
super().__init__(*args, **kwargs)
self.k = k
self.fb_embs = fb_embs
self.beta = beta
self.return_docs = return_docs
self.fb_docs = fb_docs
self.pytcfactory = pytcfactory
self.fnt = pytcfactory.nn_term(df=True)
self.r = r
import torch
import numpy as np
num_docs = self.fnt.num_docs
self.idfdict = {}
for tid in pt.tqdm(range(self.fnt.inference.query_tokenizer.tok.vocab_size)):
df = self.fnt.getDF_by_id(tid)
idfscore = np.log((1.0+num_docs)/(df+1))
self.idfdict[tid] = idfscore
assert self.k > self.fb_embs ,"fb_embs should be smaller than number of clusters"
self._init_clustering()
def _init_clustering(self):
import sklearn
from packaging.version import Version
from warnings import warn
if Version(sklearn.__version__) > Version('0.23.2'):
warn("You have sklearn version %s - sklearn KMeans clustering changed in 0.24, so performance may differ from those reported in the ICTIR 2021 paper, which used 0.23.2. "
"See also https://github.com/scikit-learn/scikit-learn/issues/19990" % str(sklearn.__version__))
def _get_centroids(self, prf_embs):
from sklearn.cluster import KMeans
kmn = KMeans(self.k, random_state=self.r)
kmn.fit(prf_embs)
return np.float32(kmn.cluster_centers_)
def transform_query(self, topic_and_res : pd.DataFrame) -> pd.DataFrame:
topic_and_res = topic_and_res.sort_values('rank')
if 'doc_embs' in topic_and_res.columns:
prf_embs = torch.cat(topic_and_res.head(self.fb_docs).doc_embs.tolist())
else:
prf_embs = torch.cat([self.pytcfactory.rrm.get_embedding(docid) for docid in topic_and_res.head(self.fb_docs).docid.values])
# perform clustering on the document embeddings to identify the representative embeddings
centroids = self._get_centroids(prf_embs)
# get the most likely tokens for each centroid
toks2freqs = self.fnt.get_nearest_tokens_for_embs(centroids)
# rank the clusters by descending idf
emb_and_score = []
for cluster, tok2freq in zip(range(self.k),toks2freqs):
if len(tok2freq) == 0:
continue
most_likely_tok = max(tok2freq, key=tok2freq.get)
tid = self.fnt.inference.query_tokenizer.tok.convert_tokens_to_ids(most_likely_tok)
emb_and_score.append( (centroids[cluster], most_likely_tok, tid, self.idfdict[tid]) )
sorted_by_second = sorted(emb_and_score, key=lambda tup: -tup[3])
# build up the new dataframe columns
toks=[]
scores=[]
exp_embds = []
for i in range(min(self.fb_embs, len(sorted_by_second))):
emb, tok, tid, score = sorted_by_second[i]
toks.append(tok)
scores.append(score)
exp_embds.append(emb)
first_row = topic_and_res.iloc[0]
# concatenate the new embeddings to the existing query embeddings
newemb = torch.cat([
first_row.query_embs,
torch.Tensor(exp_embds)])
# the weights column defines important of each query embedding
weights = torch.cat([
torch.ones(len(first_row.query_embs)),
self.beta * torch.Tensor(scores)]
)
# generate the revised query dataframe row
rtr = pd.DataFrame([
[first_row.qid,
first_row.query,
newemb,
toks,
weights ]
],
columns=["qid", "query", "query_embs", "query_toks", "query_weights"])
return rtr
def transform(self, topics_and_docs : pd.DataFrame) -> pd.DataFrame:
# validation of the input
required = ["qid", "query", "docno", "query_embs", "rank"]
for col in required:
if not col in topics_and_docs.columns:
raise KeyError("Input missing column %s, found %s" % (col, str(list(topics_and_docs.columns))) )
#restore the docid column if missing
if "docid" not in topics_and_docs.columns and "doc_embs" not in topics_and_docs.columns:
topics_and_docs = self.pytcfactory._add_docids(topics_and_docs)
rtr = []
for qid, res in topics_and_docs.groupby("qid"):
new_query_df = self.transform_query(res)
if self.return_docs:
rtr_cols = ["qid"]
for col in ["doc_embs", "doc_toks", "docid", "docno"]:
if col in res.columns:
rtr_cols.append(col)
new_query_df = res[rtr_cols].merge(new_query_df, on=["qid"])
rtr.append(new_query_df)
return pd.concat(rtr)
def _approx_maxsim_numpy(faiss_scores, faiss_ids, mapping, weights, score_buffer):
import numpy as np
faiss_depth = faiss_scores.shape[1]
pids = mapping[faiss_ids]
qemb_ids = np.arange(faiss_ids.shape[0])
for rank in range(faiss_depth):
rank_pids = pids[:, rank]
score_buffer[rank_pids, qemb_ids] = np.maximum(score_buffer[rank_pids, qemb_ids], faiss_scores[:, rank])
all_pids = np.unique(pids)
final = np.sum(score_buffer[all_pids, : ] * weights, axis=1)
score_buffer[all_pids, : ] = 0
return all_pids, final
def _approx_maxsim_defaultdict(all_scores, all_embedding_ids, mapping, qweights, ignore2):
from collections import defaultdict
pid2score = defaultdict(float)
# dont rely on ids.shape here for the number of query embeddings in the query
for qpos in range(all_scores.shape[0]):
scores = all_scores[qpos]
embedding_ids = all_embedding_ids[qpos]
pids = mapping[embedding_ids]
qpos_scores = defaultdict(float)
for (score, pid) in zip(scores, pids):
_pid = int(pid)
qpos_scores[_pid] = max(qpos_scores[_pid], score)
for (pid, score) in qpos_scores.items():
pid2score[pid] += score * qweights[ qpos].item()
return list(pid2score.keys()), list(pid2score.values())
def _approx_maxsim_sparse(all_scores, all_embedding_ids, mapping, qweights, ignore2):
from scipy.sparse import csr_matrix
import numpy as np
index_size = 9_000_000 # TODO: use total # of documents here instead of hardcoding
num_qembs = all_scores.shape[0]
faiss_depth = all_scores.shape[1]
all_pids = mapping[all_embedding_ids]
pid2score = csr_matrix((1, index_size))
for qpos in range( num_qembs ):
a = csr_matrix((all_scores[qpos], (np.arange(faiss_depth), all_pids[qpos])), shape=(faiss_depth, index_size))
pid2score += a.max(axis=0) * qweights[qpos]
return (pid2score.indices, pid2score.data)
| 50,973 | 42.642123 | 198 | py |
pyterrier_colbert | pyterrier_colbert-main/pyterrier_colbert/faiss_term_index.py | import os
import time
import random
import torch
import numpy as np
from collections import defaultdict
from multiprocessing import Pool
from colbert.modeling.inference import ModelInference
from colbert.utils.utils import print_message, flatten, batch
from colbert.indexing.loaders import get_parts
from colbert.evaluation.loaders import load_colbert
from colbert.indexing.faiss import get_faiss_index_name
from colbert.indexing.loaders import load_doclens
from tqdm import tqdm
def load_tokenids(directory):
parts, _, _ = get_parts(directory)
tokenids_filenames = [os.path.join(directory, str(part) + ".tokenids") for part in parts]
all_tokenids = torch.cat([torch.load(filename) for filename in tokenids_filenames])
return all_tokenids
class Object(object):
pass
class FaissNNTerm():
def __init__(self, colbert, index_root, index_name, nprobe=10, partitions=None, part_range=None, query_maxlen=32, faiss_index=None, cf=True, df=False, mask_punctuation=False):
if type(colbert) == str:
args = Object()
args.checkpoint = colbert
args.dim = 128
args.similarity = 'cosine'
args.query_maxlen = 32
args.doc_maxlen = 180
args.mask_punctuation = mask_punctuation
self.colbert, args.checkpoint = load_colbert(args)
else:
self.colbert = colbert
index_path = os.path.join(index_root, index_name)
if faiss_index is None:
faiss_name = None
if faiss_name is not None:
faiss_index_path = os.path.join(index_path, faiss_name)
else:
args = Object()
args.partitions = partitions
faiss_index_path = os.path.join(index_path, get_faiss_index_name(args))
print_message("#> Loading the FAISS index from", faiss_index_path, "..")
faiss_part_range = os.path.basename(faiss_index_path).split('.')[-2].split('-')
if len(faiss_part_range) == 2:
faiss_part_range = range(*map(int, faiss_part_range))
assert part_range[0] in faiss_part_range, (part_range, faiss_part_range)
assert part_range[-1] in faiss_part_range, (part_range, faiss_part_range)
else:
faiss_part_range = None
self.part_range = part_range
self.faiss_part_range = faiss_part_range
from colbert.ranking.faiss_index import FaissIndex
self.faiss_index = FaissIndex(index_path, faiss_index_path, nprobe, faiss_part_range)
else:
self.faiss_index = faiss_index
self.faiss_index.nprobe = nprobe
self.inference = ModelInference(self.colbert)
self.skips = set(self.inference.query_tokenizer.tok.special_tokens_map.values())
print_message("#> Building the emb2tid mapping..")
self.emb2tid = load_tokenids(index_path)
print(len(self.emb2tid))
self.tok = self.inference.query_tokenizer.tok
vocab_size = self.tok.vocab_size
if cf:
cfs_file = os.path.join(index_path, "cfs.stats")
if os.path.exists(cfs_file):
self.lookup = torch.load(cfs_file)
else:
print("Computing collection frequencies")
self.lookup = torch.zeros(vocab_size, dtype=torch.int64)
indx, cnt = self.emb2tid.unique(return_counts=True)
self.lookup[indx] += cnt
print("Done")
torch.save(self.lookup, cfs_file)
print("Loading doclens")
part_doclens = load_doclens(index_path, flatten=False)
import numpy as np
self.doclens = np.concatenate([np.array(part) for part in part_doclens])
self.num_docs = len(self.doclens)
self.end_offsets = np.cumsum(self.doclens)
if df:
dfs_file = os.path.join(index_path, "dfs.stats")
if os.path.exists(dfs_file):
self.dfs = torch.load(dfs_file)
else:
dfs = torch.zeros(vocab_size, dtype=torch.int64)
offset = 0
for doclen in tqdm(self.doclens, unit="d", desc="Computing document frequencies"):
tids= torch.unique(self.emb2tid[offset:offset+doclen])
dfs[tids] += 1
offset += doclen
self.dfs = dfs
torch.save(dfs, dfs_file)
def get_tokens_for_doc(self, pid):
"""
Returns the actual indexed tokens within a given document
"""
end_offset = self.end_offsets[pid]
start_offset = end_offset - self.doclens[pid]
return self.emb2tid[start_offset:end_offset]
def get_nearest_tokens_for_embs(self, embs : np.array, k=10, low_tf=0):
"""
Returns the most related terms for each of a number of given embeddings
"""
from collections import defaultdict
assert len(embs.shape) == 2
_, ids = self.faiss_index.faiss_index.search(embs, k=k)
rtrs=[]
for id_set in ids:
id2freq = defaultdict(int)
for id in id_set:
id2freq[self.emb2tid[id].item()] += 1
rtr = {}
for t, freq in sorted(id2freq.items(), key=lambda item: -1* item[1]):
if freq <= low_tf:
continue
token = self.inference.query_tokenizer.tok.decode([t])
if "[unused" in token or token in self.skips:
continue
rtr[token] = freq
rtrs.append(rtr)
return rtrs
def get_nearest_tokens_for_emb(self, emb : np.array, k=10, low_tf=0):
"""
Returns the most related terms for one given embedding
"""
return self.get_nearest_tokens_for_embs(np.expand_dims(emb, axis=0), k=k, low_tf=low_tf)[0]
def getCTF(self, term):
"""
Returns the collection frequency of a given token string.
It is assumed to be a known token(piece) to BERT, and thus not
required tokenisation
"""
id = self.tok.convert_tokens_to_ids(term)
return self.lookup[id].item()
def getCTF_by_id(self, tid):
"""
Returns the collection frequency of a given token id
"""
return self.lookup[tid].item()
def getDF(self, term):
"""
Returns the document frequency of a given token string.
It is assumed to be a known token(piece) to BERT, and thus not
required tokenisation
"""
id = self.tok.convert_tokens_to_ids(term)
return self.dfs[id].item()
def getDF_by_id(self, tid):
"""
Returns the document frequency of a given token id
"""
return self.dfs[tid].item()
def display_nn_terms(self, q, k=10, low_tf=0, n=0, by_term=True):
"""
Displays the most related terms for each query
"""
import numpy as np
with torch.no_grad():
input_ids, attention_mask = self.inference.query_tokenizer.tensorize([q])
qembs = self.inference.query(input_ids, attention_mask)
qembs = torch.nn.functional.normalize(qembs, p=2, dim=2)
#ids = self.faiss_index.queries_to_embedding_ids(k, qembs)
scores, ids = self.faiss_index.faiss_index.search(qembs[0].cpu().numpy(), k=k)
if by_term:
for (tScores, id_set, src_id) in zip(scores, ids, input_ids[0]):
token = self.inference.query_tokenizer.tok.decode([src_id])
print(token)
for embid, score in zip(id_set, tScores):
tid = self.emb2tid[embid].item()
did = self.faiss_index.emb2pid[embid].item()
token = self.inference.query_tokenizer.tok.decode([tid])
print("\t%s (embid %d tid %d did %d) %0.5f" % (token, embid, tid, did, score))
else:
id2freq = defaultdict(int)
for id_set in ids:
for id in id_set:
id2freq[self.emb2tid[id].item()] += 1
rtr = q
count=0
for t, freq in sorted(id2freq.items(), key=lambda item: -1* item[1]):
if freq <= low_tf:
continue
token = self.inference.query_tokenizer.tok.decode([t])
if "[unused" in token or token in self.skips:
continue
rtr += "\n\t" + token + " ("+str(t)+") x " + str(freq) + " "
count+= 1
if n > 0 and count == n:
break
print(rtr)
| 8,826 | 37.885463 | 179 | py |
pyterrier_colbert | pyterrier_colbert-main/tests/test_indexing.py | import unittest
import pandas as pd
import tempfile
CHECKPOINT="http://www.dcs.gla.ac.uk/~craigm/colbert.dnn.zip"
class TestIndexing(unittest.TestCase):
def _indexing_1doc(self, indexmgr, model, dim=None):
#minimum test case size is 100 docs, 40 Wordpiece tokens, and nx > k. we found 200 worked
import pyterrier as pt
from pyterrier_colbert.indexing import ColBERTIndexer
import os
indexer = ColBERTIndexer(
model,
os.path.dirname(self.test_dir),os.path.basename(self.test_dir),
chunksize=3,
#indexmgr=indexmgr,
gpu=False)
if dim is not None:
indexer.args.dim = dim
iter = pt.get_dataset("vaswani").get_corpus_iter()
indexer.index([ next(iter) for i in range(200) ])
import pyterrier_colbert.pruning as pruning
from pyterrier_colbert.ranking import ColbertPRF
for factory in [indexer.ranking_factory()]:
self.assertEqual(200, len(factory))
for pipe, has_score, name in [
(factory.end_to_end(), True, "E2E"),
(factory.prf(False), True, "PRF rank"),
(factory.prf(True), True, "PRF rerank"),
(factory.set_retrieve(), False, "set_retrieve"),
(factory.ann_retrieve_score() , True, "approx"),
((
factory.query_encoder()
>> pruning.query_embedding_pruning_first(factory, 8)
>> factory.set_retrieve(query_encoded=True)
>> factory.index_scorer(query_encoded=False)
), True, "QEP first"),
((
factory.query_encoder()
>> pruning.query_embedding_pruning(factory, 8)
>> factory.set_retrieve(query_encoded=True)
>> factory.index_scorer(query_encoded=False)
), True, "QEP ICF"),
((
factory.query_encoder()
>> pruning.query_embedding_pruning_special(CLS=True)
>> factory.set_retrieve(query_encoded=True)
>> factory.index_scorer(query_encoded=False)
), True, "QEP CLS"),
((
factory.query_encoder() >> factory.ann_retrieve_score(query_encoded=True)
), True, "ANN with query encoded"),
((
factory.query_encoder()
>> factory.ann_retrieve_score(query_encoded=True)
>> ColbertPRF(factory, fb_docs=3, fb_embs=10, beta=1.0, k=24, return_docs=True)
>> factory.index_scorer(query_encoded=True)
), True, "PRF rerank and ANN with query encoded"),
((
factory.query_encoder()
>> factory.ann_retrieve_score(query_encoded=True)
>> ColbertPRF(factory, fb_docs=3, fb_embs=10, beta=1.0, k=24, return_docs=False)
>> factory.ann_retrieve_score(query_encoded=True)
>> factory.index_scorer(query_encoded=True)
), True, "PRF rank and ANN with query encoded"),
]:
with self.subTest(name):
print("Running subtest %s" % name)
dfOut = pipe.search("chemical reactions")
self.assertTrue(len(dfOut) > 0)
if has_score:
self.assertTrue("score" in dfOut.columns)
else:
self.assertFalse("score" in dfOut.columns)
# def test_indexing_1doc_numpy(self):
# self._indexing_1doc('numpy')
# def test_indexing_1doc_half(self):
# self._indexing_1doc('half')
def indexing_docnos_correctly_empty(self):
#A test case to see whether empty passages are handled correctly.
import pyterrier as pt
from pyterrier_colbert.indexing import ColBERTIndexer
import os
indexer = ColBERTIndexer(
CHECKPOINT,
os.path.dirname(self.test_dir),os.path.basename(self.test_dir),
chunksize=3,
gpu=False)
corpus = [{ "docno" : "d%d" %i, "text": "mock documents mock documents mock documentsmock documentsmock documents mock documents mock documents mock documents mock documents mock documents mock documents mock documents mock documents "+str(i) } for i in range(150)] + [{"docno": "empty", "text":""}] + [{ "docno" : "d%d" %(i+150), "text": "mock document of clusters (100) " + str(i) } for i in range(150)]
with self.assertRaises(ValueError):
indexer.index(corpus)
def indexing_docnos_correctly_spaces(self):
#A test case to check whether passages only containing spaces are handled correctly.
import pyterrier as pt
from pyterrier_colbert.indexing import ColBERTIndexer
import os
indexer = ColBERTIndexer(
CHECKPOINT,
os.path.dirname(self.test_dir),os.path.basename(self.test_dir),
chunksize=3,
gpu=False)
corpus = [{ "docno" : "d%d" %i, "text": "mock documents mock documents mock documentsmock documentsmock documents mock documents mock documents mock documents mock documents mock documents mock documents mock documents mock documents "+str(i) } for i in range(150)] + [{"docno": "empty", "text":" "}] + [{ "docno" : "d%d" %(i+150), "text": "mock document of clusters (100) " + str(i) } for i in range(150)]
with self.assertRaises(ValueError):
indexer.index(corpus)
def indexing_empty(self):
#minimum test case size is 100 docs, 40 Wordpiece tokens, and nx > k. we found 200 worked
import pyterrier as pt
from pyterrier_colbert.indexing import ColBERTIndexer
checkpoint="http://www.dcs.gla.ac.uk/~craigm/colbert.dnn.zip"
import os
indexer = ColBERTIndexer(
CHECKPOINT,
os.path.dirname(self.test_dir),os.path.basename(self.test_dir),
chunksize=3,
gpu=False)
iter = pt.get_dataset("vaswani").get_corpus_iter()
indexer.index([ next(iter) for i in range(200) ] + [{"docno": "a", "text": ""}])
def indexing_merged(self):
#minimum test case size is 100 docs, 40 Wordpiece tokens, and nx > k. we found 200 worked
import pyterrier as pt
from pyterrier_colbert.indexing import ColBERTIndexer, merge_indices
checkpoint="http://www.dcs.gla.ac.uk/~craigm/colbert.dnn.zip"
import os
index_root = self.test_dir
indexer = ColBERTIndexer(
CHECKPOINT,
index_root, "index_part_0",
chunksize=3,
gpu=False)
iter = pt.get_dataset("vaswani").get_corpus_iter()
indexer.index([ next(iter) for i in range(200) ])
indexer = ColBERTIndexer(
CHECKPOINT,
index_root, "index_part_1",
chunksize=3,
gpu=False)
iter = pt.get_dataset("vaswani").get_corpus_iter()
indexer.index([ next(iter) for i in range(200) ])
merge_indices(index_root, "index_part")
from pyterrier_colbert.ranking import ColBERTFactory
factory = ColBERTFactory(CHECKPOINT, index_root, "index_part", faiss_partitions=100, gpu=False)
self.assertEqual(400, len(factory.docid2docno))
def test_indexing_1doc_torch(self):
self._indexing_1doc('torch', CHECKPOINT)
def test_indexing_1doc_torch_minilm(self):
import transformers
if int(transformers.__version__[0]) < 4:
self.skipTest("transfomers too old")
from colbert.modeling.colbert import ColBERT
model = ColBERT.from_pretrained("vespa-engine/col-minilm", query_maxlen=32, doc_maxlen=180, mask_punctuation=False, dim=32)
self._indexing_1doc('torch', model, dim=32)
def setUp(self):
import pyterrier as pt
if not pt.started():
pt.init()
self.test_dir = tempfile.mkdtemp()
def tearDown(self):
import shutil
try:
shutil.rmtree(self.test_dir)
except:
pass
| 8,372 | 44.016129 | 417 | py |
HetEmotionNet | HetEmotionNet-main/model/GTblock.py | import torch
import torch.nn as nn
from model.GTlayer import GTLayer
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
class permute(nn.Module):
def __init__(self):
super(permute, self).__init__()
def forward(self, x):
return x.permute(0, 2, 1)
class GTN(nn.Module):
def __init__(self, num_edge, num_channels, num_layers, norm):
super(GTN, self).__init__()
self.num_edge = num_edge
self.num_channels = num_channels
self.per = permute()
self.num_layers = num_layers
self.is_norm = norm
layers = []
for i in range(num_layers):
if i == 0:
layers.append(GTLayer(num_edge, num_channels, first=True))
else:
layers.append(GTLayer(num_edge, num_channels, first=False))
self.layers = nn.ModuleList(layers)
self.weight = nn.Parameter(torch.Tensor(1, 1))
self.loss = nn.CrossEntropyLoss()
self.reset_parameters()
def reset_parameters(self):
nn.init.xavier_uniform_(self.weight)
def gcn_conv(self, X, H):
# X shape (B,N,F)
# H shape (B,N,N)
for i in range(X.shape[-1]):
if i == 0:
out = torch.matmul(X.unsqueeze(-1)[:, :, :, i], self.weight)
else:
out = torch.cat((out, torch.matmul(X.unsqueeze(-1)[:, :, :, i], self.weight)), dim=-1)
H = self.norm(H, add=True)
out = torch.bmm(H, out)
return out
# Standardize each matrix separately
def normalization(self, H):
for i in range(self.num_channels):
if i == 0:
H_ = self.norm(H[:, i, :, :]).unsqueeze(1)
else:
H_ = torch.cat((H_, self.norm(H[:, i, :, :]).unsqueeze(1)), dim=1)
return H_
# Standardized adjacency matrix
def norm(self, H, add=True):
# H shape（b,n,n）
if add == False:
H = H * ((torch.eye(H.shape[1]) == 0).type(torch.FloatTensor)).unsqueeze(0)
else:
H = H * ((torch.eye(H.shape[1]) == 0).type(torch.FloatTensor)).unsqueeze(0).to(device) + torch.eye(
H.shape[1]).type(
torch.FloatTensor).unsqueeze(0).to(device)
deg = torch.sum(H, dim=-1)
# deg shape (b,n)
deg_inv = deg.pow(-1)
deg_inv[deg_inv == float('inf')] = 0
deg_inv = deg_inv.view((deg_inv.shape[0], deg_inv.shape[1], 1)) * torch.eye(H.shape[1]).type(
torch.FloatTensor).unsqueeze(0).to(device)
# deg_inv shape (b,n,n)
H = torch.bmm(deg_inv, H)
return H
def forward(self, A):
# A shape (B,N,N,C)
A = A.unsqueeze(1).permute(0, 1, 4, 2, 3)
Ws = []
for i in range(self.num_layers):
if i == 0:
H, W = self.layers[i](A)
else:
H = self.normalization(H)
H, W = self.layers[i](A, H)
Ws.append(W)
# H shape (b,c,n,n)
return H
| 3,037 | 31.319149 | 111 | py |
HetEmotionNet | HetEmotionNet-main/model/STDCN.py | import torch
import torch.nn as nn
import torch.nn.functional as F
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
torch.cuda.set_device(0)
class permute(nn.Module):
def __init__(self):
super(permute, self).__init__()
def forward(self, x):
return x.permute(0, 2, 1)
class permute01(nn.Module):
def __init__(self):
super(permute01, self).__init__()
def forward(self, x):
return x.permute(1, 2, 0)
class reshape(nn.Module):
def __init__(self, *args):
super(reshape, self).__init__()
self.shape = args
def forward(self, x):
return x.contiguous().view(self.shape)
class STDCN_with_GRU(nn.Module):
def __init__(self, num_f, in_dim_with_c, out_dim_with_c, num_channel):
super(STDCN_with_GRU, self).__init__()
# Number of channels before entering GRU
self.num_f = num_f
self.in_dim = in_dim_with_c
self.out_dim = out_dim_with_c
# Number of graph channels
self.num_channels = num_channel
self.per1 = permute()
self.per2 = permute()
self.per0 = permute01()
self.gru = nn.GRU(input_size=self.in_dim, hidden_size=self.out_dim, num_layers=1,
batch_first=True, bidirectional=True)
self.BN = torch.nn.BatchNorm1d(self.num_f)
# GCN weight
self.weight = nn.Parameter(torch.Tensor(1, 1))
self.soft = nn.Parameter(torch.Tensor(self.num_channels))
self.reset_parameters()
def norm(self, H, add=True):
# H shape（b,n,n）
if add == False:
H = H * ((torch.eye(H.shape[1]) == 0).type(torch.FloatTensor)).unsqueeze(0)
else:
H = H * ((torch.eye(H.shape[1]) == 0).type(torch.FloatTensor)).unsqueeze(0).to(device) + torch.eye(
H.shape[1]).type(torch.FloatTensor).unsqueeze(0).to(device)
deg = torch.sum(H, dim=-1)
# deg shape (b,n)
deg_inv = deg.pow(-1 / 2)
deg_inv = deg_inv.view((deg_inv.shape[0], deg_inv.shape[1], 1)) * torch.eye(H.shape[1]).type(
torch.FloatTensor).unsqueeze(0).to(device)
# deg_inv shape (b,n,n)
H = torch.bmm(deg_inv, H)
H = torch.bmm(H, deg_inv)
H = torch.tensor(H, dtype=torch.float32).to(device)
return H
def reset_parameters(self):
nn.init.constant_(self.weight, 10)
nn.init.constant_(self.soft, 1 / self.num_channels)
def gcn_conv(self, X, H):
# X shape (B,N,F)
# H shape (B,N,N)
for i in range(X.shape[-1]):
if i == 0:
out = torch.bmm(H, X.unsqueeze(-2)[:, :, :, i])
out = torch.matmul(out, self.weight)
else:
out = torch.cat((out, torch.matmul(torch.bmm(H, X.unsqueeze(-2)[:, :, :, i]), self.weight)),
dim=-1)
return out
def forward(self, X, H):
# Spatial
# H shape (b,c,n,n)
# x shape (b,n,in)
for i in range(self.num_channels):
if i == 0:
X_ = F.leaky_relu(self.gcn_conv(X, self.norm(H[:, i, :, :])))
X_ = X_ * self.soft[i]
else:
X_tmp = F.leaky_relu(self.gcn_conv(X, self.norm(H[:, i, :, :])))
X_tmp = X_tmp * self.soft[i]
X_ = X_ + X_tmp
# x shape (b,n,f)
# temporal
X_ = self.per1(X_)
X_, hn = self.gru(X_)
X_ = self.BN(X_)
X_ = self.per2(X_)
# x_ shape (b,NEWn,out_channel)
return X_
| 3,586 | 31.609091 | 111 | py |
HetEmotionNet | HetEmotionNet-main/model/GTlayer.py | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
class GTLayer(nn.Module):
def __init__(self, in_channels, out_channels, first=True):
super(GTLayer, self).__init__()
self.in_channels = in_channels
self.out_channels = out_channels
self.first = first # Mark whether this layer is the first GT layer
if self.first == True:
self.conv1 = GTConv(in_channels, out_channels)
self.conv2 = GTConv(in_channels, out_channels)
else:
self.conv1 = GTConv(in_channels, out_channels)
def forward(self, A, H_=None):
# A shape (b,1,c,n,n)
# Compute the new graph structure
if self.first == True:
a = self.conv1(A)
batch = a.shape[0]
num_node = a.shape[-1]
b = self.conv2(A)
a = a.view((-1, a.shape[-2], a.shape[-1]))
b = b.view((-1, b.shape[-2], b.shape[-1]))
H = torch.bmm(a, b)
H = H.view((batch, -1, num_node, num_node))
W = [(F.softmax(self.conv1.weight, dim=2)).detach(), (F.softmax(self.conv2.weight, dim=2)).detach()]
else:
a = self.conv1(A)
batch = a.shape[0]
num_node = a.shape[-1]
a = a.view((-1, a.shape[-2], a.shape[-1]))
H_ = H_.view(-1, H_.shape[-2], H_.shape[-1])
H = torch.bmm(H_, a)
H = H.view((batch, -1, num_node, num_node))
W = [(F.softmax(self.conv1.weight, dim=2)).detach()]
return H, W
# GT layer
class GTConv(nn.Module):
def __init__(self, in_channels, out_channels):
super(GTConv, self).__init__()
self.in_channels = in_channels
self.out_channels = out_channels
self.weight = nn.Parameter(torch.Tensor(1, out_channels, in_channels, 1, 1))
self.bias = None
self.scale = nn.Parameter(torch.Tensor([0.1]), requires_grad=False)
self.reset_parameters()
def reset_parameters(self):
n = self.in_channels
nn.init.constant_(self.weight, 0.1)
nn.init.uniform_(self.weight, 0, 1)
if self.bias is not None:
fan_in, _ = nn.init._calculate_fan_in_and_fan_out(self.weight)
bound = 1 / math.sqrt(fan_in)
nn.init.uniform_(self.bias, -bound, bound)
def forward(self, A):
# A shape (b,1,c,n,n)
self.weight = self.weight.to(device)
A = torch.sum(A * F.softmax(self.weight, dim=2), dim=2)
# A shape (b,out,n,n)
return A
| 2,628 | 34.527027 | 112 | py |
HetEmotionNet | HetEmotionNet-main/model/prototype.py | import torch as t
from model.GTblock import GTN
from model.STDCN import *
class permute(nn.Module):
def __init__(self):
super(permute, self).__init__()
def forward(self, x):
return x.permute(0, 2, 1)
class Net(nn.Module):
def __init__(self, model_config):
super(Net, self).__init__()
# Load model configuration
self.num_node = int(model_config['num_node'])
self.num_edge = int(model_config['num_edge'])
self.final_out_node = int(model_config['final_out_node'])
self.dropout = float(model_config['dropout'])
self.sample_feature_num = int(model_config['sample_feature_num'])
self.per1 = permute()
self.batchnorm = nn.BatchNorm1d(self.num_node - 32)
self.batchnorm_F = nn.BatchNorm1d(self.num_node)
# Registration layer
self.GT_F = GTN(3, 3, 3, 0)
self.GT_T = GTN(3, 3, 3, 0)
self.STDCN1_F = STDCN_with_GRU(4, self.num_node, self.final_out_node, 3)
# Note that the feature number is multiplied by two after the bi-GRU comes out
self.STDCN1_T = STDCN_with_GRU(self.sample_feature_num, self.num_node, self.final_out_node, 3)
self.flatten = nn.Flatten()
self.flatten = nn.Flatten()
self.linF = nn.Linear(4, self.sample_feature_num // 2)
self.linT = nn.Linear(self.sample_feature_num, self.sample_feature_num // 2)
self.all = self.sample_feature_num * self.final_out_node * 2
self.Dropout = nn.Dropout(0.2)
self.lin1 = nn.Linear(self.all, 64)
self.act1 = nn.LeakyReLU()
self.lin2 = nn.Linear(64, 2)
def forward(self, data):
x_F, x_T, A = data.FS, data.TS, data.A
x_F = self.Dropout(x_F)
x_T = self.Dropout(x_T)
A = A.view((-1, self.num_node, self.num_node, self.num_edge))
x_F = x_F.view((-1, self.num_node, x_F.shape[-1]))
x_T = x_T.view((-1, self.num_node, x_T.shape[-1]))
# GTN
H_F = self.GT_F(A)
H_T = self.GT_T(A)
# GCN and GRU
out_F = self.STDCN1_F(x_F, H_F)
out_F = self.linF(out_F)
out_F = self.flatten(out_F)
out_T = self.STDCN1_T(x_T, H_T)
out_T = self.linT(out_T)
out_T = self.flatten(out_T)
# Fusion and classification
out = t.cat([out_F, out_T], dim=-1)
out = self.lin1(out)
out = self.act1(out)
out = self.lin2(out)
return out
| 2,448 | 36.676923 | 102 | py |
HetEmotionNet | HetEmotionNet-main/model/utils.py | import torch as t
import numpy as np
from torch_geometric.data import Dataset, Data
import scipy.io as sio
import os
device = t.device('cuda' if t.cuda.is_available() else 'cpu')
@t.no_grad()
def acc(net, labels, label_num, dataloader):
# Calculate the confusion matrix and accuracy of the current batch
confusion_matrix = t.zeros(3, 3).to(device)
for i, data in enumerate(dataloader):
data = data.to(device)
pred = net(data).argmax(dim=1)
truth = data.Y.view(-1, labels)[:, label_num]
confusion_matrix[0, 0] += t.sum((pred == 0).long() * (truth == 0).long())
confusion_matrix[0, 1] += t.sum((pred == 1).long() * (truth == 0).long())
confusion_matrix[0, 2] += t.sum((pred == 2).long() * (truth == 0).long())
confusion_matrix[1, 0] += t.sum((pred == 0).long() * (truth == 1).long())
confusion_matrix[1, 1] += t.sum((pred == 1).long() * (truth == 1).long())
confusion_matrix[1, 2] += t.sum((pred == 2).long() * (truth == 1).long())
confusion_matrix[2, 0] += t.sum((pred == 0).long() * (truth == 2).long())
confusion_matrix[2, 1] += t.sum((pred == 1).long() * (truth == 2).long())
confusion_matrix[2, 2] += t.sum((pred == 2).long() * (truth == 2).long())
return t.div(t.trace(confusion_matrix), t.sum(confusion_matrix)), confusion_matrix
def accuracy(mat):
return t.trace(mat) / t.sum(mat)
def recall(mat):
return mat[0][0] / t.sum(mat[0])
def precision(mat):
return mat[0][0] / t.sum(mat[:, 0])
def F1_score(mat):
return 2 * recall(mat) * precision(mat) / (recall(mat) + precision(mat))
| 1,624 | 35.931818 | 86 | py |
GANonymization | GANonymization-main/main.py | import os.path
import pathlib
import shutil
import cv2
import fire
import pandas as pd
import pytorch_lightning
import torchvision.transforms
from loguru import logger
from sklearn.model_selection import train_test_split
from torchvision.transforms import RandomHorizontalFlip, Compose
from torchvision.utils import save_image
from lib.datasets import DatasetSplit
from lib.datasets.label_extractor import extract_labels
from lib.datasets.labeled_dataset import LabeledDataset
from lib.evaluator import eval_classifier
from lib.models.generic_classifier import GenericClassifier
from lib.models.pix2pix import Pix2Pix
from lib.trainer import setup_torch_device, setup
from lib.transform import transform, FacialLandmarks478, FaceCrop, FaceSegmentation, ZeroPaddingResize, \
Pix2PixTransformer
from lib.utils import glob_dir, get_last_ckpt, move_files
SEED = 42
def preprocess(input_path: str, img_size: int = 512, align: bool = True, test_size: float = 0.1, shuffle: bool = True,
output_dir: str = None, num_workers: int = 8):
"""
Run all pre-processing steps (split, crop, segmentation, landmark) at once.
@param input_path: The path to a directory to be processed.
@param img_size: The size of the image after the processing step.
@param align: True if the images should be aligned centered after padding.
@param test_size: The size of the test split. (Default: 0.1)
@param shuffle: Shuffle the split randomly.
@param output_dir: The output directory.
@param num_workers: The number of cpu-workers.
"""
logger.info(f"Parameters: {', '.join([f'{key}: {value}' for key, value in locals().items()])}")
if output_dir is None:
output_dir = input_path
output_dir = os.path.join(output_dir, 'original')
# Split dataset
split_file = extract_labels(input_path, output_dir)
if split_file:
df = pd.read_csv(split_file)
for split, folder in enumerate(['train', 'val', 'test']):
move_files([os.path.join(input_path, img_path.replace('\\', os.sep)) for img_path in
df[df['split'] == split]['image_path'].values], os.path.join(output_dir, folder))
shutil.copyfile(split_file, os.path.join(output_dir, pathlib.Path(split_file).name))
else:
files = glob_dir(os.path.join(input_path))
logger.debug(f'Found {len(files)} images')
train_files, test_files = train_test_split(files, test_size=test_size, shuffle=shuffle)
move_files(train_files, os.path.join(output_dir, 'train'))
move_files(test_files, os.path.join(output_dir, 'val'))
# Apply Transformers
output_dir = transform(output_dir, img_size, False, FaceCrop(align, True), num_workers=num_workers)
output_dir = transform(output_dir, img_size, False, FaceSegmentation(), num_workers=num_workers)
output_dir = transform(output_dir, img_size, True, FacialLandmarks478(), num_workers=num_workers)
def train_pix2pix(data_dir: str, log_dir: str, models_dir: str, output_dir: str, dataset_name: str, epoch: int = 0,
n_epochs: int = 200, batch_size: int = 1, lr: float = 0.0002, b1: float = 0.5, b2: float = 0.999,
n_cpu: int = 2, img_size: int = 256, checkpoint_interval: int = 500, device: int = 0):
"""
Train the pix2pix GAN for generating faces based on given landmarks.
@param data_dir: The root path to the data folder.
@param log_dir: The log folder path.
@param models_dir: The path to the models.
@param output_dir: The output directory.
@param dataset_name: name of the dataset.
@param epoch: epoch to start training from.
@param n_epochs: number of epochs of training.
@param batch_size: size of the batches.
@param lr: adam: learning rate.
@param b1: adam: decay of first order momentum of gradient.
@param b2: adam: decay of first order momentum of gradient.
@param n_cpu: number of cpu threads to use during batch generation.
@param img_size: size of image.
@param checkpoint_interval: interval between model checkpoints.
@param device: The device to run the task on (e.g., device >= 0: cuda; device=-1: cpu).
"""
logger.info(f"Parameters: {', '.join([f'{key}: {value}' for key, value in locals().items()])}")
setup_torch_device(device, SEED)
ckpt_file = get_last_ckpt(models_dir)
resume_ckpt = None
if ckpt_file is not None:
resume_ckpt = os.path.join(models_dir, ckpt_file)
model = Pix2Pix.load_from_checkpoint(resume_ckpt)
else:
model = Pix2Pix(data_dir, models_dir, output_dir, n_epochs, dataset_name, batch_size, lr, b1,
b2, n_cpu, img_size, device)
trainer = setup(model, log_dir, models_dir, n_epochs, device, checkpoint_interval=checkpoint_interval)
trainer.fit(model, ckpt_path=resume_ckpt)
def train_classifier(data_dir: str, num_classes: int, learning_rate: float = 0.0003, batch_size: int = 128,
n_epochs: int = 100, device: int = 0, output_dir: str = 'output', monitor: str = 'val_loss',
metric_mode: str = 'min', save_top_k: int = 1, early_stop_n: int = 5, num_workers: int = 8):
"""
Run the training.
@param data_dir:
@param num_classes:
@param learning_rate: The learning rate.
@param batch_size: The batch size.
@param n_epochs: The number of epochs to train.
@param device: The device to work on.
@param output_dir: The path to the output directory.
@param monitor: The metric variable to monitor.
@param metric_mode: The mode of the metric to decide which checkpoint to choose (min or max).
@param save_top_k: Save checkpoints every k epochs - or every epoch if k=0.
@param early_stop_n: Stops training after n epochs of no improvement - default is deactivated.
@param num_workers:
"""
logger.info(f"Parameters: {', '.join([f'{key}: {value}' for key, value in locals().items()])}")
pytorch_lightning.seed_everything(SEED, workers=True)
train_db = LabeledDataset(data_dir, DatasetSplit.TRAIN, Compose([
GenericClassifier.weights.transforms(),
RandomHorizontalFlip(),
]))
val_db = LabeledDataset(data_dir, DatasetSplit.VALIDATION,
Compose([GenericClassifier.weights.transforms()]))
model = GenericClassifier(train_db=train_db, val_db=val_db, multi_label=train_db.is_multi_label,
batch_size=batch_size, learning_rate=learning_rate, num_workers=num_workers,
device=setup_torch_device(device, SEED), classes=train_db.classes,
class_weights=train_db.class_weight)
models_dir = os.path.join(output_dir, 'models')
trainer = setup(model=model, log_dir=os.path.join(output_dir, 'logs'),
models_dir=models_dir, num_epoch=n_epochs,
device=device, monitor=monitor, metric_mode=metric_mode,
save_top_k=save_top_k, early_stop_n=early_stop_n)
trainer.fit(model)
eval_classifier(models_dir, data_dir, batch_size, device, output_dir, num_workers)
def anonymize_image(model_file: str, input_file: str, output_file: str, img_size: int = 512, align: bool = True,
device: int = 0):
"""
Anonymize one face in a single image.
@param model_file: The GANonymization model to be used for anonymization.
@param input_file: The input image file.
@param output_file: The output image file.
@param img_size: The size of the image for processing by the model.
@param align: Whether to align the image based on the facial orientation.
@param device: The device to run the process on.
"""
img = cv2.imread(input_file)
transform = torchvision.transforms.Compose([
FaceCrop(align, False),
ZeroPaddingResize(img_size),
FacialLandmarks478(),
Pix2PixTransformer(model_file, img_size, device)
])
transformed_img = transform(img)
os.makedirs(os.path.dirname(output_file), exist_ok=True)
save_image(transformed_img, output_file, normalize=True)
def anonymize_directory(model_file: str, input_directory: str, output_directory: str, img_size: int = 512,
align: bool = True, device: int = 0):
"""
Anonymize a set of images in a directory.
@param model_file: The GANonymization model to be used for anonymization.
@param input_directory: The input image directory.
@param output_directory: The output image directory.
@param img_size: The size of the image for processing by the model.
@param align: Whether to align the image based on the facial orientation.
@param device: The device to run the process on.
"""
for file in os.listdir(input_directory):
anonymize_image(model_file, file, os.path.join(output_directory, os.path.basename(file)), img_size, align,
device)
if __name__ == '__main__':
fire.Fire()
| 8,989 | 48.395604 | 118 | py |
GANonymization | GANonymization-main/lib/analysis.py | import math
import os.path
import numpy as np
import pandas as pd
import torch
from PIL import Image
from deepface import DeepFace
from loguru import logger
from matplotlib import pyplot as plt
from scipy.stats import shapiro, wilcoxon
from statsmodels.stats.multitest import multipletests
from torchvision.transforms import Compose, Resize, ToTensor
from torchvision.utils import save_image
from tqdm import tqdm
from lib.datasets import DatasetSplit
from lib.datasets.labeled_dataset import LabeledDataset
from lib.models.generic_classifier import GenericClassifier
from lib.transform import FaceSegmentation, Pix2PixTransformer
def emotion_analysis(db_path: str, result_path: str):
db_name = os.path.basename(db_path)
logger.debug(f'Analysis for {db_name}')
# Load labeled datasets
db_seg = LabeledDataset(os.path.join(db_path, 'segmentation'), DatasetSplit.VALIDATION, Compose([]))
db_gan = LabeledDataset(os.path.join(db_path, 'ganonymization'), DatasetSplit.VALIDATION, Compose([]))
db_dp2 = LabeledDataset(os.path.join(db_path, 'deepprivacy2'), DatasetSplit.VALIDATION, Compose([]))
# Load predicted labels
npz_seg = np.load(os.path.join(result_path, 'segmentation', 'result_pred_label.npz'))
npz_gan = np.load(os.path.join(result_path, 'ganonymization', 'result_pred_label.npz'))
npz_dp2 = np.load(os.path.join(result_path, 'deepprivacy2', 'result_pred_label.npz'))
# Create dataframes with predicted labels and image names
df_seg = db_seg.meta_data
df_gan = db_gan.meta_data
df_dp2 = db_dp2.meta_data
df_seg_pred = pd.DataFrame(npz_seg['pred'], columns=db_seg.classes)
df_gan_pred = pd.DataFrame(npz_gan['pred'], columns=db_seg.classes)
df_dp2_pred = pd.DataFrame(npz_dp2['pred'], columns=db_seg.classes)
df_seg_pred['image_name'] = [os.path.basename(f).split('-')[-1] for f in df_seg['image_path']]
df_gan_pred['image_name'] = [os.path.basename(f).split('-')[-1] for f in df_gan['image_path']]
df_dp2_pred['image_name'] = [os.path.basename(f).split('-')[-1] for f in df_dp2['image_path']]
# Calculate mean distance between original and synthesized images for each category
synthesized_label = [f'{c}_x' for c in db_seg.classes]
original_label = [f'{c}_y' for c in db_seg.classes]
df = pd.DataFrame(index=[c.replace('_', ' ') for c in db_seg.classes])
df_seg_gan_pred = pd.merge(df_gan_pred, df_seg_pred, on='image_name')
df_seg_dp2_pred = pd.merge(df_dp2_pred, df_seg_pred, on='image_name')
df['GANonymization'] = [(df_seg_gan_pred[x] - df_seg_gan_pred[y]).abs().mean() for x, y in zip(synthesized_label, original_label)]
df['DeepPrivacy2'] = [(df_seg_dp2_pred[x] - df_seg_dp2_pred[y]).abs().mean() for x, y in zip(synthesized_label, original_label)]
# Save results
df.to_csv(os.path.join(result_path, f'{db_name}_mean_distance.csv'))
df.to_latex(os.path.join(result_path, f'{db_name}_mean_distance.latex'))
if len(original_label) < 20:
fig_width = int(round(len(df.index) / 2))
if fig_width < 4:
fig_width = 4
df.plot.bar(figsize=(fig_width, 4))
plt.ylabel('Mean Distance')
plt.xlabel('Category')
plt.legend(loc='upper right')
plt.tight_layout()
plt.savefig(os.path.join(result_path, f'{db_name}_mean_distance.png'))
plt.close()
else:
df_split = np.array_split(df, int(round(len(original_label) / 20)))
for idx, df_tmp in enumerate(df_split):
fig_width = int(round(len(df_tmp.index) / 2))
if fig_width < 4:
fig_width = 4
df_tmp.plot.bar(figsize=(fig_width, 4))
plt.ylabel('Mean Distance')
plt.xlabel('Category')
plt.legend(loc='upper center')
plt.tight_layout()
plt.savefig(os.path.join(result_path, f'{db_name}_{idx}_mean_distance.png'))
plt.close()
# T-Test
df_seg_gan_pred = pd.merge(df_gan_pred, df_seg_pred, left_on='image_name', right_on='image_name')
ganonymization = np.asarray(
[(df_seg_gan_pred[x] - df_seg_gan_pred[y]).abs().to_numpy() for x, y in zip(synthesized_label, original_label)])
df_seg_dp2_pred = pd.merge(df_dp2_pred, df_seg_pred, left_on='image_name', right_on='image_name')[
df_dp2_pred['image_name'].isin(df_gan_pred['image_name'])]
deepprivacy2 = np.asarray(
[(df_seg_dp2_pred[x] - df_seg_dp2_pred[y]).abs().to_numpy() for x, y in zip(synthesized_label, original_label)])
ganonymization = ganonymization.transpose()
deepprivacy2 = deepprivacy2.transpose()
results = {}
for col_idx in range(len(ganonymization[0])):
_, pvalue = shapiro(np.concatenate([ganonymization[:, col_idx], deepprivacy2[:, col_idx]]))
logger.debug(f'Shapiro: {pvalue}')
result = wilcoxon(ganonymization[:, col_idx], deepprivacy2[:, col_idx], method='approx')
n = len(ganonymization[:, col_idx])
r = result.zstatistic / math.sqrt(n)
logger.info(
f'{wilcoxon.__name__}-{original_label[col_idx]}: p-value={result.pvalue}, statistic={result.statistic}, zstatistic={result.zstatistic}, n={n}, r={r}')
results.setdefault('pvalue', []).append(result.pvalue)
# results.setdefault('statistic', []).append(result.statistic)
results.setdefault('zstatistic', []).append(result.zstatistic)
results.setdefault('r', []).append(r)
results.setdefault('n', []).append(n)
reject, pvals_corrected, _, _ = multipletests(np.asarray(results['pvalue']), method='bonferroni')
logger.info(f'\nP-Values (corrected): {pvals_corrected}')
df = pd.DataFrame(results,
index=[c.replace('_', ' ') for c in db_seg.classes])
df.rename({'pvalue': 'P-Value', 'zstatistic': 'Z-Statistic', 'n': 'N'}, axis=1, inplace=True)
df.to_csv(os.path.join(result_path, f'statistic_pvalue.csv'))
df.to_latex(os.path.join(result_path, f'statistic_pvalue.latex'))
def face_comparison_analysis(output_dir: str, img_orig_path: str, *img_paths, img_size: int = 512):
def original_filename(file):
return file.split('-')[-1]
os.makedirs(output_dir, exist_ok=True)
sub_dir = 'val'
img_dirs = {
os.path.basename(path): [os.path.join(path, sub_dir, f) for f in os.listdir(os.path.join(path, sub_dir))]
for path in img_paths}
img_dirs_short = {method: [original_filename(path) for path in paths] for method, paths in img_dirs.items()}
comp_result = []
transformers = Compose([Resize(img_size), ToTensor()])
for orig_img in tqdm(os.listdir(os.path.join(img_orig_path, sub_dir)), desc='Comparison'):
images = {'original': os.path.join(img_orig_path, sub_dir, orig_img)}
for method, paths in img_dirs.items():
if original_filename(orig_img) in img_dirs_short[method]:
images[method] = img_dirs[method][
[original_filename(p) for p in paths].index(original_filename(orig_img))]
if len(images) < len(img_paths) + 1:
continue
for idx, items in enumerate(images.items()):
db_name, img_path = items
# Predict similarity of faces
verify_result = {'distance': 0, 'threshold': 0}
if idx > 0:
tmp_result = DeepFace.verify(images['original'], img_path, model_name="VGG-Face",
detector_backend='skip', enforce_detection=False, align=False)
if len(verify_result) > 0:
verify_result = tmp_result
comp_result.append([db_name, original_filename(img_path), verify_result['distance'],
verify_result['threshold']])
img_sample = torch.cat(
[transformers(Image.open(images['original'])), transformers(Image.open(images['deepprivacy2'])),
transformers(Image.open(images['ganonymization']))], -2)
save_image(img_sample, os.path.join(output_dir, original_filename(orig_img)), normalize=True)
df = pd.DataFrame(comp_result, columns=['dataset', 'filename', 'distance', 'threshold'])
df.to_csv(os.path.join(output_dir, 'prediction_result.csv'))
df_distance_mean = df.groupby(['dataset'])['distance'].mean()
threshold_mean = df.groupby(['dataset'])['threshold'].mean()['ganonymization']
df_distance_mean.to_csv(os.path.join(output_dir, 'mean_prediction_result.csv'))
df_distance_mean.transpose().plot.bar(rot=0)
plt.axhline(y=threshold_mean, ls='dashed', color='b')
plt.ylabel('Mean Cosine Distance')
plt.xlabel('Anonymization Method')
plt.savefig(os.path.join(output_dir, 'mean_distance_per_method.png'))
plt.close()
logger.debug(f'Analyze comparison for: {output_dir}')
df = pd.read_csv(os.path.join(output_dir, 'prediction_result.csv'))
df_gan = df[df['dataset'] == 'ganonymization'].reset_index()
df_dp2 = df[df['dataset'] == 'deepprivacy2'].reset_index()
df_gan_nan = df_gan[df_gan['distance'].isna()]['filename'].index
df_gan.drop(df_gan_nan, inplace=True)
df_dp2.drop(df_gan_nan, inplace=True)
df_gan = df_gan['distance'].to_numpy()
df_dp2 = df_dp2['distance'].to_numpy()
_, pvalue = shapiro(np.concatenate([df_gan, df_dp2]))
logger.debug(f'Shapiro: {pvalue}')
result = wilcoxon(df_gan, df_dp2, method='approx')
n = len(df_gan)
r = result.zstatistic / math.sqrt(n)
logger.info(
f'{wilcoxon.__name__}: p-value={result.pvalue}, statistic={result.statistic}, zstatistic={result.zstatistic}, n={n}, r={r}')
reject, pvals_corrected, _, _ = multipletests(result.pvalue, method='bonferroni')
logger.info(
f'{wilcoxon.__name__}: p-value={result.pvalue}, statistic={result.statistic}, zstatistic={result.zstatistic}, n={n}, r={r}')
df = pd.DataFrame({'P-Value': pvals_corrected, 'Z-Statistic': result.zstatistic, 'r': r, 'N': n})
df.to_csv(os.path.join(output_dir, f'statistic_pvalue.csv'))
df.to_latex(os.path.join(output_dir, f'statistic_pvalue.latex'))
def facial_traits_analysis(data_dir: str, model_file: str, output_dir: str):
db_seg = LabeledDataset(os.path.join(data_dir, FaceSegmentation.__class__.__name__), DatasetSplit.VALIDATION,
Compose([GenericClassifier.weights.transforms()]))
db_seg.meta_data['image_name'] = db_seg.meta_data['image_path'].apply(
lambda f: os.path.basename(f).split('-')[-1]).values.tolist()
db_gan = LabeledDataset(os.path.join(data_dir, Pix2PixTransformer.__class__.__name__), DatasetSplit.VALIDATION,
Compose([GenericClassifier.weights.transforms()]))
db_gan.meta_data['image_name'] = db_gan.meta_data['image_path'].apply(
lambda f: os.path.basename(f).split('-')[-1]).values.tolist()
db_seg.meta_data.drop(db_seg.meta_data[~db_seg.meta_data['image_name'].isin(db_gan.meta_data['image_name'])].index,
inplace=True)
db_seg.meta_data.reset_index(inplace=True)
model = GenericClassifier.load_from_checkpoint(model_file, classes=db_seg.classes)
result_positive = {label: 0 for label in db_seg.classes}
result_negative = {label: 0 for label in db_seg.classes}
for idx in tqdm(range(len(db_seg)), total=len(db_seg)):
pred_seg = model.predict(torch.unsqueeze(db_seg[idx][0].to(model.device), dim=0))[0]
if torch.any(pred_seg > 0.5):
pred_gan = model.predict(torch.unsqueeze(db_gan[idx][0].to(model.device), dim=0))[0]
pred_seg = pred_seg.cpu().detach().numpy()
pred_gan = pred_gan.cpu().detach().numpy()
for label_idx in range(db_seg.num_classes):
if pred_seg[label_idx] > 0.5 and pred_gan[label_idx] > 0.5:
result_positive[db_seg.classes[label_idx]] += 1
elif pred_seg[label_idx] > 0.5 and pred_gan[label_idx] <= 0.5:
result_negative[db_seg.classes[label_idx]] += 1
df_pos = pd.read_csv(os.path.join(output_dir, 'result', 'positive.csv'), index_col=0)
df_neg = pd.read_csv(os.path.join(output_dir, 'result', 'negative.csv'), index_col=0)
df = pd.merge(df_pos, df_neg, right_index=True, left_index=True)
result = df['Negative'] / df.sum(axis=1)
result = pd.DataFrame(result, columns=['GANonymization'])
result = result.rename(index={s: s.replace('_', ' ') for s in result.index.values})
result = result.sort_values('GANonymization', ascending=False)
result.to_csv(os.path.join(output_dir, 'result', 'traits_removed.csv'))
result.to_latex(os.path.join(output_dir, 'result', 'traits_removed.latex'))
df_split = np.array_split(result, int(round(len(result) / 20)))
for idx, df_tmp in enumerate(df_split):
fig_width = int(round(len(df_tmp.index) / 2))
if fig_width < 4:
fig_width = 4
df_tmp.plot.bar(figsize=(fig_width, 4))
plt.gca().set_ylim([0, 1])
plt.ylabel('Removed (in %)')
plt.xlabel('Category')
plt.tight_layout()
plt.savefig(os.path.join(output_dir, 'result', f'{idx}_traits_removed.png'))
plt.close()
| 13,171 | 52.112903 | 162 | py |
GANonymization | GANonymization-main/lib/evaluator.py | import os.path
import numpy as np
import pandas as pd
import seaborn as sn
import torch
from loguru import logger
from matplotlib import pyplot as plt
from mpl_toolkits.axes_grid1 import ImageGrid
from sklearn.metrics import classification_report
from torch.utils.data import DataLoader
from torchmetrics.classification import MulticlassConfusionMatrix, MultilabelConfusionMatrix
from torchvision.transforms import Compose
from tqdm import tqdm
from lib.datasets import DatasetSplit
from lib.datasets.labeled_dataset import LabeledDataset
from lib.models.generic_classifier import GenericClassifier
from lib.utils import get_last_ckpt
def eval_classifier(models_dir: str, data_dir: str, batch_size: int = 128, device: int = 0,
output_dir: str = 'output', num_workers: int = 2):
logger.info(f"Parameters: {', '.join([f'{key}: {value}' for key, value in locals().items()])}")
os.makedirs(output_dir, exist_ok=True)
val_db = LabeledDataset(data_dir, DatasetSplit.VALIDATION,
Compose([GenericClassifier.weights.transforms()]))
model = GenericClassifier.load_from_checkpoint(get_last_ckpt(models_dir), classes=val_db.classes,
multi_label=val_db.is_multi_label)
model.eval()
model.to(device)
if model.multi_label:
cm = MultilabelConfusionMatrix(num_labels=val_db.num_classes, normalize='true').to(device)
logger.debug('Setting up evaluation for multi-label classification')
else:
cm = MulticlassConfusionMatrix(num_classes=val_db.num_classes, normalize='true').to(device)
logger.debug('Setting up evaluation for multi-class classification')
dl = DataLoader(val_db, batch_size=batch_size, num_workers=num_workers)
all_label = []
all_pred = []
for batch in tqdm(dl, desc='Evaluation'):
images, labels = batch
pred = model.predict(images.to(device))
labels = labels.to(device)
if val_db.is_multi_label:
ml_pred = torch.round(pred).int()
ml_labels = labels.int()
cm.update(ml_pred, ml_labels)
else:
mc_labels = torch.argmax(labels, dim=1)
cm.update(pred, mc_labels)
all_label.extend(labels.cpu().detach().numpy())
all_pred.extend(pred.cpu().detach().numpy())
# Confusion Matrix
all_label = np.asarray(all_label)
all_pred = np.asarray(all_pred)
np.savez_compressed(os.path.join(output_dir, 'result_pred_label.npz'), pred=all_pred, label=all_label)
conf_matrix = cm.compute()
conf_matrix = conf_matrix.cpu().detach().numpy()
logger.debug('Creating Confusion Matrix...')
if model.multi_label:
n_columns = int(model.num_classes / 4)
n_rows = int(model.num_classes / n_columns)
fig = plt.figure(figsize=(n_columns * 2, n_rows * 2))
plt.tight_layout()
grid = ImageGrid(fig, 111,
nrows_ncols=(n_rows, n_columns),
axes_pad=0.5,
share_all=True,
cbar_mode='single',
cbar_location='right',
cbar_size='5%',
cbar_pad=0.5)
for idx in tqdm(range(conf_matrix.shape[0]), desc='Multi-Label Confusion Matrices'):
label = model.classes[idx]
binary_labels = ['Present', 'Absent']
df_cm = pd.DataFrame(conf_matrix[idx, :, :], index=binary_labels, columns=binary_labels)
df_cm.to_csv(os.path.join(output_dir, f'{os.path.basename(data_dir)}_{label}_confusion_matrix.csv'))
sn.set(font_scale=1.3)
sn.heatmap(df_cm, annot=True, fmt='.2f', xticklabels=binary_labels, yticklabels=binary_labels,
ax=grid[idx], cbar_ax=grid[0].cax, annot_kws={'fontsize': 13})
grid[idx].set_ylabel('Actual')
grid[idx].set_xlabel('Predicted')
grid[idx].set_title(label.replace('_', ' ').replace('-', ' '))
plt.tight_layout()
plt.savefig(os.path.join(output_dir, f'{os.path.basename(data_dir)}_confusion_matrix.png'))
plt.close()
else:
df_cm = pd.DataFrame(conf_matrix, index=val_db.labels, columns=val_db.labels)
df_cm.to_csv(os.path.join(output_dir, f'{os.path.basename(data_dir)}_confusion_matrix.csv'))
plt.figure(figsize=(
len(val_db.labels) + int(len(val_db.labels) / 2), len(val_db.labels) + int(len(val_db.labels) / 2)))
plt.tight_layout()
sn.set(font_scale=1.3)
sn.heatmap(df_cm, annot=True, fmt='.2f', xticklabels=val_db.labels, yticklabels=val_db.labels, annot_kws={
'fontsize': 13
})
plt.ylabel('Actual')
plt.xlabel('Predicted')
plt.savefig(os.path.join(output_dir, f'{os.path.basename(data_dir)}_confusion_matrix.png'))
plt.close()
logger.debug('Confusion Matrix created!')
# Classification Report
logger.debug('Creating Classification Report...')
if model.multi_label:
all_label = np.round(all_label)
all_pred = np.round(all_pred)
else:
all_label = np.squeeze(np.argmax(all_label, axis=1))
all_pred = np.squeeze(np.argmax(all_pred, axis=1))
report = classification_report(all_label, all_pred, target_names=val_db.labels)
with open(os.path.join(output_dir, f'{os.path.basename(data_dir)}_classification_report.txt'),
'w+') as f:
f.write(report)
logger.debug('Classification Report created!')
| 5,557 | 46.913793 | 114 | py |
GANonymization | GANonymization-main/lib/trainer.py | import os
import random
import numpy as np
import pytorch_lightning
import torch
from loguru import logger
from pytorch_lightning import LightningModule
from pytorch_lightning.callbacks import ModelCheckpoint, LearningRateMonitor, EarlyStopping
from pytorch_lightning.loggers import TensorBoardLogger
def setup_torch_device(device: int, seed: int) -> str:
"""
Set up the torch device with a seed.
@param device: The device the model should be run on.
@param seed: The seed for the run.
@return: The string of the device.
"""
torch_device = f'cuda:{device}' if device >= 0 else 'cpu'
logger.info(f"Using {'GPU.' if device >= 0 else 'CPU, as was explicitly requested, or as GPU is not available.'}")
np.random.seed(seed)
torch.manual_seed(seed)
random.seed(seed)
pytorch_lightning.seed_everything(seed)
if device >= 0:
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
torch.cuda.manual_seed_all(seed)
torch.cuda.manual_seed(seed)
return torch_device
def setup(model: LightningModule, log_dir: str, models_dir: str, num_epoch: int, device: int,
save_top_k: int = 0, monitor: str = None, metric_mode: str = None, early_stop_n: int = 0,
checkpoint_interval: int = None) -> pytorch_lightning.Trainer:
"""
Run the lightning model.
:param model: The model to train.
:param num_epoch: The number of epochs to train.
:param device: The device to work on.
:param save_top_k: Save top k checkpoints - or every epoch if k=0.
:param monitor: The metric variable to monitor.
:param metric_mode: The mode of the metric to decide which checkpoint to choose (min or max).
:param early_stop_n: Stops training after n epochs of no improvement - default is deactivated.
:param checkpoint_interval: The interval a checkpoint should be saved if save_top_k is 0.
"""
model_name = model.__class__.__name__
os.makedirs(models_dir, exist_ok=True)
os.makedirs(log_dir, exist_ok=True)
tb_logger = TensorBoardLogger(log_dir, name='', version='')
callbacks = [LearningRateMonitor()]
if save_top_k > 0:
callbacks.append(ModelCheckpoint(dirpath=models_dir, filename='{epoch}-{' + monitor + ':.6f}',
save_top_k=save_top_k, monitor=monitor, mode=metric_mode))
else:
callbacks.append(
ModelCheckpoint(dirpath=models_dir, filename='{epoch}-{step}', monitor='step', mode='max',
save_top_k=-1, every_n_train_steps=checkpoint_interval))
if early_stop_n > 0:
callbacks.append(
EarlyStopping(monitor=monitor, min_delta=0.00, patience=early_stop_n, verbose=False, mode=metric_mode))
trainer = pytorch_lightning.Trainer(deterministic=True,
accelerator="gpu" if device >= 0 else "cpu",
devices=[device] if device >= 0 else None,
callbacks=callbacks,
logger=tb_logger,
max_epochs=num_epoch,
val_check_interval=checkpoint_interval,
log_every_n_steps=1,
detect_anomaly=True)
logger.info(
f'Train {model_name} for {num_epoch} epochs and save logs under {tb_logger.log_dir} and models under {models_dir}')
model.train()
model.to(device)
return trainer
| 3,589 | 45.025641 | 123 | py |
GANonymization | GANonymization-main/lib/models/pix2pix.py | import os.path
import pytorch_lightning
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import transforms
from torchvision.utils import save_image, make_grid
from lib.datasets.image_dataset import ImageDataset
def weights_init_normal(m):
classname = m.__class__.__name__
if classname.find("Conv") != -1:
nn.init.normal_(m.weight.data, 0.0, 0.02)
elif classname.find("BatchNorm2d") != -1:
nn.init.normal_(m.weight.data, 1.0, 0.02)
nn.init.constant_(m.bias.data, 0.0)
##############################
# U-NET
##############################
class UNetDown(nn.Module):
def __init__(self, in_size, out_size, normalize=True, dropout=0.0):
super(UNetDown, self).__init__()
layers = [nn.Conv2d(in_size, out_size, 4, 2, 1, bias=False)]
if normalize:
layers.append(nn.InstanceNorm2d(out_size))
layers.append(nn.LeakyReLU(0.2))
if dropout:
layers.append(nn.Dropout(dropout))
self.model = nn.Sequential(*layers)
def forward(self, x):
return self.model(x)
class UNetUp(nn.Module):
def __init__(self, in_size, out_size, dropout=0.0):
super(UNetUp, self).__init__()
layers = [
nn.ConvTranspose2d(in_size, out_size, 4, 2, 1, bias=False),
nn.InstanceNorm2d(out_size),
nn.ReLU(inplace=True),
]
if dropout:
layers.append(nn.Dropout(dropout))
self.model = nn.Sequential(*layers)
def forward(self, x, skip_input):
x = self.model(x)
x = torch.cat((x, skip_input), 1)
return x
class GeneratorUNet(nn.Module):
def __init__(self, in_channels=3, out_channels=3):
super(GeneratorUNet, self).__init__()
self.down1 = UNetDown(in_channels, 64, normalize=False)
self.down2 = UNetDown(64, 128)
self.down3 = UNetDown(128, 256)
self.down4 = UNetDown(256, 512, dropout=0.5)
self.down5 = UNetDown(512, 512, dropout=0.5)
self.down6 = UNetDown(512, 512, dropout=0.5)
self.down7 = UNetDown(512, 512, dropout=0.5)
self.down8 = UNetDown(512, 512, normalize=False, dropout=0.5)
self.up1 = UNetUp(512, 512, dropout=0.5)
self.up2 = UNetUp(1024, 512, dropout=0.5)
self.up3 = UNetUp(1024, 512, dropout=0.5)
self.up4 = UNetUp(1024, 512, dropout=0.5)
self.up5 = UNetUp(1024, 256)
self.up6 = UNetUp(512, 128)
self.up7 = UNetUp(256, 64)
self.final = nn.Sequential(
nn.Upsample(scale_factor=2),
nn.ZeroPad2d((1, 0, 1, 0)),
nn.Conv2d(128, out_channels, 4, padding=1),
nn.Tanh(),
)
def forward(self, x):
# U-Net generator with skip connections from encoder to decoder
d1 = self.down1(x)
d2 = self.down2(d1)
d3 = self.down3(d2)
d4 = self.down4(d3)
d5 = self.down5(d4)
d6 = self.down6(d5)
d7 = self.down7(d6)
d8 = self.down8(d7)
u1 = self.up1(d8, d7)
u2 = self.up2(u1, d6)
u3 = self.up3(u2, d5)
u4 = self.up4(u3, d4)
u5 = self.up5(u4, d3)
u6 = self.up6(u5, d2)
u7 = self.up7(u6, d1)
return self.final(u7)
##############################
# Discriminator
##############################
class Discriminator(nn.Module):
def __init__(self, in_channels=3):
super(Discriminator, self).__init__()
def discriminator_block(in_filters, out_filters, normalization=True):
"""Returns downsampling layers of each discriminator block"""
layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]
if normalization:
layers.append(nn.InstanceNorm2d(out_filters))
layers.append(nn.LeakyReLU(0.2, inplace=True))
return layers
self.model = nn.Sequential(
*discriminator_block(in_channels * 2, 64, normalization=False),
*discriminator_block(64, 128),
*discriminator_block(128, 256),
*discriminator_block(256, 512),
nn.ZeroPad2d((1, 0, 1, 0)),
nn.Conv2d(512, 1, 4, padding=1, bias=False)
)
def forward(self, img_A, img_B):
# Concatenate image and condition image by channels to produce input
img_input = torch.cat((img_A, img_B), 1)
return self.model(img_input)
##############################
# Lightning
##############################
class Pix2Pix(pytorch_lightning.LightningModule):
def __init__(self, data_dir: str, models_dir: str, output_dir: str, n_epochs: int,
dataset_name: str, batch_size: int, lr: float, b1: float, b2: float, n_cpu: int, img_size: int,
device: int):
"""
Create a Pix2Pix Network.
@param data_dir: The directory of the data.
@param models_dir: The directory of the models.
@param output_dir: The directory of the output.
@param n_epochs: The number of epochs.
@param dataset_name: The name of the dataset which is appended to the output_dir.
@param batch_size: The size of the batches to process.
@param lr: The learning rate.
@param b1: The beta 1 value for the optimizer.
@param b2: The beta 2 value for the optimizer.
@param n_cpu: The number of cpus.
@param img_size: The size of the image.
@param device: The device to run the computation on.
"""
super().__init__()
self.save_hyperparameters()
self.automatic_optimization = False
self.data_dir = data_dir
self.models_dir = models_dir
self.output_dir = output_dir
self.n_epochs = n_epochs
self.dataset_name = dataset_name
self.batch_size = batch_size
self.lr = lr
self.b1 = b1
self.b2 = b2
self.n_cpu = n_cpu
self.img_size = img_size
self.out_dir = os.path.join(output_dir, dataset_name)
os.makedirs(self.out_dir, exist_ok=True)
self.transforms_ = [
transforms.Resize((img_size, img_size)),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
]
self.criterion_GAN = torch.nn.MSELoss()
self.criterion_GAN.to(device)
self.criterion_pixelwise = torch.nn.L1Loss()
self.criterion_pixelwise.to(device)
self.lambda_pixel = 100
self.generator = GeneratorUNet()
self.generator.to(device)
self.discriminator = Discriminator()
self.discriminator.to(device)
# Initialize weights
self.generator.apply(weights_init_normal)
self.discriminator.apply(weights_init_normal)
def forward(self, x):
return self.generator(x)
def training_step(self, batch):
optimizer_g, optimizer_d = self.optimizers()
# Model inputs
real_A = batch["B"]
real_B = batch["A"]
# Calculate output of image discriminator (PatchGAN)
patch = (1, self.img_size // 2 ** 4, self.img_size // 2 ** 4)
# Adversarial ground truths
valid = torch.ones((real_A.size(0), *patch), requires_grad=False).to(self.device)
fake = torch.zeros((real_A.size(0), *patch), requires_grad=False).to(self.device)
# ------------------
# Train Generators
# ------------------
self.toggle_optimizer(optimizer_g)
# GAN loss
fake_B = self.generator(real_A)
pred_fake = self.discriminator(fake_B, real_A)
loss_GAN = self.criterion_GAN(pred_fake, valid)
# Pixel-wise loss
loss_pixel = self.criterion_pixelwise(fake_B, real_B)
# Total loss
loss_G = loss_GAN + self.lambda_pixel * loss_pixel
self.log('G loss', loss_G, prog_bar=True)
self.log('G pixel', loss_pixel, prog_bar=True)
self.log('G adv', loss_GAN, prog_bar=True)
self.manual_backward(loss_G)
optimizer_g.step()
optimizer_g.zero_grad()
self.untoggle_optimizer(optimizer_g)
# ---------------------
# Train Discriminator
# ---------------------
self.toggle_optimizer(optimizer_d)
# Real loss
pred_real = self.discriminator(real_B, real_A)
loss_real = self.criterion_GAN(pred_real, valid)
# Fake loss
fake_B = self.generator(real_A)
pred_fake = self.discriminator(fake_B.detach(), real_A)
loss_fake = self.criterion_GAN(pred_fake, fake)
# Total loss
loss_D = 0.5 * (loss_real + loss_fake)
self.log('D loss', loss_D, prog_bar=True)
self.manual_backward(loss_D)
optimizer_d.step()
optimizer_d.zero_grad()
self.untoggle_optimizer(optimizer_d)
def validation_step(self, batch, batch_idx):
if batch_idx == 0:
real_A = batch["B"]
real_B = batch["A"]
fake_B = self.generator(real_A)
img_sample = torch.cat((real_B.data, real_A.data, fake_B.data), -2)
save_image(img_sample, os.path.join(self.out_dir, f'{self.current_epoch}-{self.global_step}.png'), nrow=5,
normalize=True)
grid = make_grid(img_sample, nrow=5, normalize=True)
self.logger.experiment.add_image('images', grid, self.global_step)
def configure_optimizers(self):
optimizer_g = torch.optim.Adam(self.generator.parameters(), lr=self.lr, betas=(self.b1, self.b2))
optimizer_d = torch.optim.Adam(self.discriminator.parameters(), lr=self.lr, betas=(self.b1, self.b2))
return [optimizer_g, optimizer_d], []
def train_dataloader(self):
return DataLoader(
ImageDataset(os.path.join(self.data_dir, self.dataset_name), transforms_=self.transforms_),
batch_size=self.batch_size,
shuffle=True,
num_workers=self.n_cpu,
)
def val_dataloader(self):
return DataLoader(
ImageDataset(os.path.join(self.data_dir, self.dataset_name), transforms_=self.transforms_, mode="val"),
batch_size=10,
shuffle=True,
num_workers=self.n_cpu,
)
| 10,286 | 34.843206 | 118 | py |
GANonymization | GANonymization-main/lib/models/generic_classifier.py | from typing import List
import pytorch_lightning as pl
import torch
from loguru import logger
from pytorch_lightning.cli import ReduceLROnPlateau
from torch import nn, Tensor
from torch.utils.data import DataLoader
from torchmetrics.classification import MulticlassAccuracy, MultilabelAccuracy
from torchvision.models import convnext_base, ConvNeXt_Base_Weights
from lib.datasets.labeled_dataset import LabeledDataset
class GenericClassifier(pl.LightningModule):
"""
The GenericClassifier is based on the ConvNeXt architecture and
can be used to train a multi-class or multi-label problem.
"""
weights = ConvNeXt_Base_Weights.DEFAULT
def __init__(self, multi_label: bool, classes: List[str], batch_size: int,
learning_rate: float, num_workers: int, device: str, val_db: LabeledDataset = None,
train_db: LabeledDataset = None, class_weights: Tensor = None):
"""
Create a new GenericClassifier.
@param multi_label: If the problem at hand is multi-label then True otherwise False for multi-class.
@param classes: The class names as a list.
@param batch_size: The size of the batches.
@param learning_rate: The learning rate.
@param num_workers: The number of cpu-workers.
@param device: The device to run the model on.
@param val_db: The validation dataset.
@param train_db: The training dataset.
@param class_weights: The class weights of the dataset.
"""
super().__init__()
# Settings
self.train_db = train_db
self.val_db = val_db
self.learning_rate = learning_rate
self.batch_size = batch_size
self.num_workers = num_workers
self.multi_label = multi_label
self.classes = classes
self.num_classes = len(classes)
# Define model architecture
self.model = convnext_base(weights=self.weights)
self.model.classifier[-1] = nn.Linear(self.model.classifier[-1].in_features, self.num_classes)
self.class_weights = class_weights.float().to(device)
# Loss function, accuracy
if self.multi_label:
logger.debug(f'Model is a Multi-Label Classificator')
self.loss_function = torch.nn.BCEWithLogitsLoss(reduction='none').to(device)
self.activation = torch.nn.Sigmoid().to(device)
self.metrics = {
'accuracy': MultilabelAccuracy(num_labels=self.num_classes).to(device)
}
else:
logger.debug(f'Model is a Multi-Class Classificator')
self.loss_function = torch.nn.CrossEntropyLoss(weight=self.class_weights).to(device)
self.activation = torch.nn.Softmax(dim=1).to(device)
self.metrics = {
'top_1_acc': MulticlassAccuracy(top_k=1, num_classes=self.num_classes).to(device),
'top_5_acc': MulticlassAccuracy(top_k=5, num_classes=self.num_classes).to(device),
}
self.save_hyperparameters(ignore=['val_db', 'train_db'])
def forward(self, x):
return self.model(x)
def predict(self, x):
return self.activation(self.forward(x))
def configure_optimizers(self):
optimizer = torch.optim.AdamW(params=self.parameters(), lr=self.learning_rate, weight_decay=0.001)
scheduler = ReduceLROnPlateau(optimizer, monitor='val_loss', patience=3)
return [optimizer], [{'scheduler': scheduler, 'interval': 'epoch', 'monitor': 'val_loss'}]
def training_step(self, train_batch, batch_idx):
loss, _ = self.step('train', train_batch)
return loss
def train_dataloader(self):
return DataLoader(self.train_db, batch_size=self.batch_size, shuffle=True, num_workers=self.num_workers)
def validation_step(self, val_batch, batch_idx):
_, labels = val_batch
_, output = self.step('val', val_batch)
if not self.multi_label:
labels = torch.argmax(labels, dim=1)
for key, metric in self.metrics.items():
self.log(f'val_{key}', metric(output, labels), prog_bar=True)
def val_dataloader(self):
return DataLoader(self.val_db, batch_size=self.batch_size, shuffle=True, num_workers=self.num_workers)
def step(self, tag: str, batch):
images, labels = batch
output = self.forward(images)
if self.multi_label:
loss = self.loss_function(output, labels)
loss = (loss * self.class_weights).mean()
else:
loss = self.loss_function(output, torch.argmax(labels, dim=1))
self.log(f'{tag}_loss', loss.item(), prog_bar=True)
return loss, output
| 4,690 | 42.036697 | 112 | py |
GANonymization | GANonymization-main/lib/datasets/image_dataset.py | import os
import numpy as np
import torchvision.transforms as transforms
from PIL import Image
from torch.utils.data import Dataset
from lib.utils import glob_dir
class ImageDataset(Dataset):
"""
An ImageDataset manages the access to images in a folder structure of train, val, and test.
"""
def __init__(self, root, transforms_=None, mode="train"):
"""
Create a new ImageDataset.
@param root: The root folder of the dataset.
@param transforms_: The transformers to be applied to the image before the images are handed over.
@param mode: The mode either "train", "val", or "test".
"""
# Set True if training data shall be mirrored for augmentation purposes:
self._MIRROR_IMAGES = False
self.transform = transforms.Compose(transforms_)
self.files = sorted(glob_dir(os.path.join(root, mode)))
self.files.extend(sorted(glob_dir(os.path.join(root, mode))))
if mode == "train":
self.files.extend(sorted(glob_dir(os.path.join(root, "test"))))
self.files.extend(sorted(glob_dir(os.path.join(root, "test"))))
def __getitem__(self, index):
file_path = self.files[index % len(self.files)]
img = Image.open(file_path)
w, h = img.size
img_A = img.crop((0, 0, int(w / 2), h))
img_B = img.crop((int(w / 2), 0, w, h))
if self._MIRROR_IMAGES:
if np.random.random() < 0.5:
img_A = Image.fromarray(np.array(img_A)[:, ::-1, :], "RGB")
img_B = Image.fromarray(np.array(img_B)[:, ::-1, :], "RGB")
img_A = self.transform(img_A)
img_B = self.transform(img_B)
return {"A": img_A, "B": img_B, "Filepath": file_path}
def __len__(self):
return len(self.files)
| 1,808 | 36.6875 | 106 | py |
GANonymization | GANonymization-main/lib/datasets/labeled_dataset.py | import json
import os
from typing import List, Tuple
import numpy as np
import pandas as pd
import torch
from PIL import Image
from loguru import logger
from sklearn.utils import compute_class_weight
from torch import Tensor
from torch.utils.data import DataLoader
from torchvision.transforms import Compose
from lib.datasets import DatasetSplit
from lib.utils import glob_dir
class LabeledDataset(torch.utils.data.Dataset):
"""
The LabeledDataset wraps a folder structure of a dataset with train, val, and test folders
and the corresponding labels.csv with the meta information.
"""
def __init__(self, data_dir: str, split: DatasetSplit, transforms: Compose):
"""
Create a new LabeledDataset.
@param data_dir: The root directory of the dataset.
@param split: Which dataset split should be considered.
@param transforms: The transformations that are applied to the images before returning.
"""
data_dir = os.path.join(data_dir, split.value['folder'])
logger.debug(f'Setup LabeledDataset on path: {data_dir}')
# Load meta-data from labels.csv and filter by the split
df = pd.read_csv(os.path.join(os.path.dirname(data_dir), 'labels.csv'))
self.meta_data = df[df['split'] == split.value['value']]
# Search for all files available in the filesystem
files_found = glob_dir(data_dir)
file_names_found = [os.path.basename(f).split('-')[-1] for f in files_found]
logger.debug(f'Files found: {len(file_names_found)}')
# Extract base name from image_path in meta-data
self.meta_data['image_path'] = self.meta_data['image_path'].apply(lambda p: p.split('\\')[-1].split('/')[-1])
# Filter for all available images in files_found
self.meta_data = self.meta_data[self.meta_data['image_path'].isin(file_names_found)]
logger.debug(f'Files not available: {len(file_names_found) - len(self.meta_data)}')
self.meta_data['image_path'] = self.meta_data['image_path'].apply(
lambda p: files_found[file_names_found.index(p)] if p in file_names_found else p)
# Extract labels from meta-data
self.labels = list(self.meta_data.drop(['image_path', 'split'], axis=1).columns.values)[1:]
self.transforms = transforms
logger.info(f'Finished "{os.path.basename(data_dir)}" Dataset (total={len(self.meta_data)}) Setup!')
def __len__(self) -> int:
return len(self.meta_data)
def __getitem__(self, idx) -> Tuple[Tensor, np.ndarray]:
df = self.meta_data.iloc[idx]
img = Image.open(df["image_path"])
img = self.transforms(img)
labels = df[self.labels].astype(float).to_numpy()
return img, labels
@property
def classes(self) -> List[str]:
"""
@return: The class labels as list.
"""
return self.labels
@property
def num_classes(self) -> int:
"""
@return: The number of classes.
"""
return len(self.classes)
@property
def is_multi_label(self) -> bool:
"""
@return: If the dataset represents a multiple labels at once.
"""
return (self.meta_data[self.labels].sum(axis=1) > 1).any()
@property
def class_weight(self) -> Tensor:
"""
Compute the class weights for the dataset.
@return: The class weights as tensor.
"""
logger.debug(f'Compute class weights with {self.num_classes} classes: {", ".join(self.classes)}')
logger.debug(f'Sum of samples per class:\n{self.meta_data[self.labels].sum(axis=0)}')
if self.is_multi_label:
y = self.meta_data[self.labels].to_numpy()
class_weight = np.empty([self.num_classes, 2])
for idx in range(self.num_classes):
class_weight[idx] = compute_class_weight(class_weight='balanced', classes=[0., 1.], y=y[:, idx])
class_weight = np.mean(class_weight, axis=1)
else:
y = np.argmax(self.meta_data[self.labels].to_numpy(), axis=1)
class_weight = compute_class_weight(class_weight='balanced', classes=range(self.num_classes), y=y)
class_weights_per_label = {self.labels[idx]: class_weight[idx] for idx in range(len(self.labels))}
logger.debug(f'Class-Weights for each Label={json.dumps(class_weights_per_label, indent=3)}')
return torch.from_numpy(class_weight)
| 4,453 | 41.826923 | 117 | py |
GANonymization | GANonymization-main/lib/datasets/unlabeled_dataset.py | import os
from typing import Tuple
import numpy as np
import torch
from PIL import Image
from loguru import logger
from torch import Tensor
from torch.utils.data import DataLoader
from torchvision.transforms import Compose
from lib.datasets import DatasetSplit
from lib.utils import glob_dir
class UnlabeledDataset(torch.utils.data.Dataset):
"""
The LabeledDataset wraps a folder structure of a dataset with train, val, and test folders
and the corresponding labels.csv with the meta information.
"""
def __init__(self, data_dir: str, split: DatasetSplit, transforms: Compose):
"""
Create a new LabeledDataset.
@param data_dir: The root directory of the dataset.
@param split: Which dataset split should be considered.
@param transforms: The transformations that are applied to the images before returning.
"""
data_dir = os.path.join(data_dir, split.value['folder'])
logger.debug(f'Setup LabeledDataset on path: {data_dir}')
# Search for all files available in the filesystem
self.files_found = glob_dir(data_dir)
self.transforms = transforms
logger.info(f'Finished "{os.path.basename(data_dir)}" Dataset (total={len(self)}) Setup!')
def __len__(self) -> int:
return len(self.files_found)
def __getitem__(self, idx) -> Tuple[Tensor, np.ndarray]:
img = Image.open(self.files_found[idx])
img = self.transforms(img)
return img, np.asarray([-1])
| 1,506 | 34.046512 | 98 | py |
GANonymization | GANonymization-main/lib/transform/pix2pix_transformer.py | import torch
from torchvision.transforms import transforms
from lib.models.pix2pix import Pix2Pix
class Pix2PixTransformer:
"""
The GANonymization transformer synthesizes images based on facial landmarks images.
"""
def __init__(self, model_file: str, img_size: int, device: int):
self.model = Pix2Pix.load_from_checkpoint(model_file)
self.model.eval()
self.model.to(device)
self.device = device
self.transforms_ = transforms.Compose([
transforms.ToTensor(),
transforms.Resize((img_size, img_size)),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
])
def __call__(self, pic):
"""
@param pic (PIL Image or numpy.ndarray): Image to be converted to a face image.
@return: Tensor: Converted image.
"""
pic_transformed = self.transforms_(pic)
pic_transformed_device = pic_transformed.to(self.device)
pic_transformed_device_batched = torch.unsqueeze(pic_transformed_device, dim=0)
return self.model(pic_transformed_device_batched)
def __repr__(self) -> str:
return f"{self.__class__.__name__}"
| 1,182 | 32.8 | 87 | py |
brian2hears | brian2hears-master/docs_sphinx/conf.py | # -*- coding: utf-8 -*-
#
# brian2hears documentation build configuration file
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import sys
import os
import shlex
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
sys.path.insert(0, os.path.abspath('.'))
sys.path.insert(0, os.path.abspath('..'))
brian2hears_dir = os.path.abspath(os.path.join(os.path.dirname(__file__),
'..', 'brian2hears'))
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
needs_sphinx = '1.7'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.autosectionlabel',
'sphinx.ext.autosummary',
'sphinx.ext.napoleon',
'sphinx.ext.doctest',
'sphinx.ext.intersphinx',
'sphinx.ext.mathjax',
'sphinx.ext.viewcode',
'sphinx.ext.extlinks',
'sphinx.ext.inheritance_diagram',
'sphinx_gallery.gen_gallery'
]
sphinx_gallery_conf = {
'examples_dirs': '../examples', # path to your example scripts
'gallery_dirs': 'auto_examples', # path where to save gallery generated examples
'filename_pattern': '/',
'reference_url': {
'brian2hears': None, # None means "this project"
}
}
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
# source_suffix = ['.rst', '.md']
source_suffix = '.rst'
# The encoding of source files.
#source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = u'brian2hears'
copyright = u'2019, Brian authors'
author = u'Brian authors'
# By default, e.g. when running on readthedocs, we do not run the example files
# and mock most dependencies (except for matplotlib and numpy which are needed
# by sphinx-gallery even when not running the examples)
if not os.environ.get('RUN_EXAMPLES', 'FALSE').lower() == 'true':
import sys
try:
from unittest.mock import Mock, MagicMock
except ImportError:
from mock import Mock, MagicMock
MOCK_MODULES = ['scipy',
'scipy.io',
'scipy.io.wavfile',
'scipy.signal',
'scipy.special',
'brian2',
'brian2.core',
'brian2.core.functions',
'brian2.codegen',
'brian2.codegen.cpp_prefs', 'brian2.codegen.runtime',
'brian2.codegen.runtime.cython_rt',
'brian2.codegen.runtime.cython_rt.cython_rt',
'brian2.codegen.runtime.cython_rt.extension_manager',
'brian2.devices',
'brian2.devices.device',
'brian2.units',
'brian2.units.fundamentalunits',
'brian2.utils',
'brian2.utils.logger']
sys.modules.update((mod_name, Mock()) for mod_name in MOCK_MODULES)
# Additional hacks to get the documentation to build (numbers/units that appear
# as default arguments of functions are evaluated and need to support multiply
# divide, etc. – the Mock objects don't)
sys.modules['brian2'].kHz = 1000.0
sys.modules['brian2'].ms = 0.001
sys.modules['brian2'].usecond = 0.000001
sys.modules['brian2'].second = 1.
sys.modules['brian2'].metre = 1.
sys.modules['brian2'].Hz = 1.
# Used as a parent class
sys.modules['brian2'].NeuronGroup = object
# The mocked check_units decorator hides all the docstrings
from functools import wraps
def check_units(*args, **kwds):
def do_check_units(f):
@wraps(f)
def new_f(*args, **kwds):
return f(*args, **kwds)
return new_f
return do_check_units
sys.modules['brian2'].check_units = check_units
# Do not execute the examples
sphinx_gallery_conf['plot_gallery'] = 'False'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
version = '0.9'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = []
# The reST default role (used for this markup: `text`) to use for all
# documents.
default_role = 'obj'
# If true, '()' will be appended to :func: etc. cross-reference text.
#add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
modindex_common_prefix = ['brian2hears.']
# If true, keep warnings as "system message" paragraphs in the built documents.
#keep_warnings = False
# If true, `todo` and `todoList` produce output, else they produce nothing.
todo_include_todos = False
# -- Options for HTML output ----------------------------------------------
# on_rtd is whether we are on readthedocs.org, this line of code grabbed from docs.readthedocs.org
on_rtd = os.environ.get('READTHEDOCS', None) == 'True'
if not on_rtd:
# ReadTheDocs theme
try:
import sphinx_rtd_theme
html_theme = "sphinx_rtd_theme"
html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
except ImportError:
pass # use the default theme
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#html_theme_options = {}
# Add any paths that contain custom themes here, relative to this directory.
#html_theme_path = []
# The name for this set of Sphinx documents. If None, it defaults to
# "<project> v<release> documentation".
#html_title = None
# A shorter title for the navigation bar. Default is the same as html_title.
#html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
#html_logo = None
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# Add any extra paths that contain custom files (such as robots.txt or
# .htaccess) here, relative to this directory. These files are copied
# directly to the root of the documentation.
#html_extra_path = []
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
#html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
#html_additional_pages = {}
# If false, no module index is generated.
#html_domain_indices = True
# If false, no index is generated.
#html_use_index = True
# If true, the index is split into individual pages for each letter.
#html_split_index = False
# If true, links to the reST sources are added to the pages.
#html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
#html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
#html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
#html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
#html_file_suffix = None
# Language to be used for generating the HTML full-text search index.
# Sphinx supports the following languages:
# 'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'
# 'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr'
#html_search_language = 'en'
# A dictionary with options for the search language support, empty by default.
# Now only 'ja' uses this config value
#html_search_options = {'type': 'default'}
# The name of a javascript file (relative to the configuration directory) that
# implements a search results scorer. If empty, the default will be used.
#html_search_scorer = 'scorer.js'
# Output file base name for HTML help builder.
htmlhelp_basename = 'brian2hearssdoc'
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#'preamble': '',
# Latex figure (float) alignment
#'figure_align': 'htbp',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(master_doc, 'brian2hears.tex', u'brian2hears Documentation',
u'Brian authors', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
#latex_logo = None
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
#latex_use_parts = False
# If true, show page references after internal links.
#latex_show_pagerefs = False
# If true, show URL addresses after external links.
#latex_show_urls = False
# Documents to append as an appendix to all manuals.
#latex_appendices = []
# If false, no module index is generated.
#latex_domain_indices = True
# -- Options for Epub output ----------------------------------------------
# Bibliographic Dublin Core info.
epub_title = project
epub_author = author
epub_publisher = author
epub_copyright = copyright
# The basename for the epub file. It defaults to the project name.
#epub_basename = project
# The HTML theme for the epub output. Since the default themes are not optimized
# for small screen space, using the same theme for HTML and epub output is
# usually not wise. This defaults to 'epub', a theme designed to save visual
# space.
#epub_theme = 'epub'
# The language of the text. It defaults to the language option
# or 'en' if the language is not set.
#epub_language = ''
# The scheme of the identifier. Typical schemes are ISBN or URL.
#epub_scheme = ''
# The unique identifier of the text. This can be a ISBN number
# or the project homepage.
#epub_identifier = ''
# A unique identification for the text.
#epub_uid = ''
# A tuple containing the cover image and cover page html template filenames.
#epub_cover = ()
# A sequence of (type, uri, title) tuples for the guide element of content.opf.
#epub_guide = ()
# HTML files that should be inserted before the pages created by sphinx.
# The format is a list of tuples containing the path and title.
#epub_pre_files = []
# HTML files shat should be inserted after the pages created by sphinx.
# The format is a list of tuples containing the path and title.
#epub_post_files = []
# A list of files that should not be packed into the epub file.
epub_exclude_files = ['search.html']
# The depth of the table of contents in toc.ncx.
#epub_tocdepth = 3
# Allow duplicate toc entries.
#epub_tocdup = True
# Choose between 'default' and 'includehidden'.
#epub_tocscope = 'default'
# Fix unsupported image types using the Pillow.
#epub_fix_images = False
# Scale large images.
#epub_max_image_width = 0
# How to display URL addresses: 'footnote', 'no', or 'inline'.
#epub_show_urls = 'inline'
# If false, no index is generated.
#epub_use_index = True
intersphinx_mapping = {'python': ('https://docs.python.org/', None),
'brian2': ('https://brian2.readthedocs.org/en/stable/', None),
'matplotlib': ('http://matplotlib.org/', None),
'numpy': ('http://docs.scipy.org/doc/numpy/', None),
'scipy': ('http://docs.scipy.org/doc/scipy/reference/', None)}
# Configure linking to github
extlinks = {'issue': ('https://github.com/brian-team/brian2hears/issues/%s','#')}
| 13,993 | 32.801932 | 98 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/models/keras/load.py | from keras.models import load_model as keras_load_model
from .resnet.resnet import sensitivity, specificity, j_stat, compare_scores
def load_model(filename, custom_objects={'sensitivity': sensitivity, 'specificity': specificity, 'j_stat': j_stat,
'compare_scores': compare_scores}):
return keras_load_model(filename, custom_objects=custom_objects) | 394 | 55.428571 | 114 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/models/keras/senet/se_resnet.py | '''
Squeeze-and-Excitation ResNets
References:
- [Deep Residual Learning for Image Recognition](https://arxiv.org/abs/1512.03385)
- []() # added when paper is published on Arxiv
'''
from __future__ import print_function
from __future__ import absolute_import
from __future__ import division
from keras.models import Model
from keras.layers import Input
from keras.layers import Dense
from keras.layers import Activation
from keras.layers import BatchNormalization
from keras.layers import MaxPooling3D
from keras.layers import GlobalAveragePooling3D
from keras.layers import GlobalMaxPooling3D
from keras.layers import Conv3D
from keras.layers import add
from keras.regularizers import l2
from keras.engine.topology import get_source_inputs
from keras import backend as K
from .se import squeeze_excite_block
WEIGHTS_PATH = ""
WEIGHTS_PATH_NO_TOP = ""
def SEResNet(input_shape=None,
num_outputs=1000,
initial_conv_filters=64,
depth=(3, 4, 6, 3),
filters=(64, 128, 256, 512),
width=1,
bottleneck=False,
weight_decay=1e-4,
include_top=True,
weights=None,
input_tensor=None,
pooling=None,
**kwargs):
""" Instantiate the Squeeze and Excite ResNet architecture. Note that ,
when using TensorFlow for best performance you should set
`image_data_format="channels_last"` in your Keras config
at ~/.keras/keras.json.
The model are compatible with both
TensorFlow and Theano. The dimension ordering
convention used by the model is the one
specified in your Keras config file.
# Arguments
initial_conv_filters: number of features for the initial convolution
depth: number or layers in the each block, defined as a list.
ResNet-50 = [3, 4, 6, 3]
ResNet-101 = [3, 6, 23, 3]
ResNet-152 = [3, 8, 36, 3]
filter: number of filters per block, defined as a list.
filters = [64, 128, 256, 512
width: width multiplier for the network (for Wide ResNets)
bottleneck: adds a bottleneck conv to reduce computation
weight_decay: weight decay (l2 norm)
include_top: whether to include the fully-connected
layer at the top of the network.
weights: `None` (random initialization) or `imagenet` (trained
on ImageNet)
input_tensor: optional Keras tensor (i.e. output of `layers.Input()`)
to use as image input for the model.
input_shape: optional shape tuple, only to be specified
if `include_top` is False (otherwise the input shape
has to be `(224, 224, 3)` (with `tf` dim ordering)
or `(3, 224, 224)` (with `th` dim ordering).
It should have exactly 3 inputs channels,
and width and height should be no smaller than 8.
E.g. `(200, 200, 3)` would be one valid value.
pooling: Optional pooling mode for feature extraction
when `include_top` is `False`.
- `None` means that the output of the model will be
the 4D tensor output of the
last convolutional layer.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional layer, and thus
the output of the model will be a 3D tensor.
- `max` means that global max pooling will
be applied.
num_outputs: optional number of num_outputs to classify images
into, only to be specified if `include_top` is True, and
if no `weights` argument is specified.
# Returns
adjacency_matrix Keras model instance.
"""
if weights not in {'imagenet', None}:
raise ValueError('The `weights` argument should be either '
'`None` (random initialization) or `imagenet` '
'(pre-training on ImageNet).')
if weights == 'imagenet' and include_top and num_outputs != 1000:
raise ValueError('If using `weights` as imagenet with `include_top`'
' as true, `classes` should be 1000')
assert len(depth) == len(filters), "The length of filter increment list must match the length " \
"of the depth list."
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
img_input = Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
x = _create_se_resnet(num_outputs, img_input, include_top, initial_conv_filters,
filters, depth, width, bottleneck, weight_decay, pooling, **kwargs)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = Model(inputs, x, name='resnext')
# load weights
return model
def SEResNet18(input_shape=None,
num_outputs=1000,
width=1,
bottleneck=False,
weight_decay=1e-4,
include_top=True,
weights=None,
input_tensor=None,
pooling=None,
**kwargs):
return SEResNet(input_shape,
depth=[2, 2, 2, 2],
width=width,
bottleneck=bottleneck,
weight_decay=weight_decay,
include_top=include_top,
weights=weights,
input_tensor=input_tensor,
pooling=pooling,
num_outputs=num_outputs,
**kwargs)
def SEResNet34(input_shape=None,
num_outputs=1000,
width=1,
bottleneck=False,
weight_decay=1e-4,
include_top=True,
weights=None,
input_tensor=None,
pooling=None,
**kwargs):
return SEResNet(input_shape,
depth=[3, 4, 6, 3],
width=width,
bottleneck=bottleneck,
weight_decay=weight_decay,
include_top=include_top,
weights=weights,
input_tensor=input_tensor,
pooling=pooling,
num_outputs=num_outputs,
**kwargs)
def SEResNet50(input_shape=None,
num_outputs=1000,
width=1,
bottleneck=True,
weight_decay=1e-4,
include_top=True,
weights=None,
input_tensor=None,
pooling=None,
**kwargs):
return SEResNet(input_shape,
width=width,
bottleneck=bottleneck,
weight_decay=weight_decay,
include_top=include_top,
weights=weights,
input_tensor=input_tensor,
pooling=pooling,
num_outputs=num_outputs,
**kwargs)
def SEResNet101(input_shape=None,
num_outputs=1000,
width=1,
bottleneck=True,
weight_decay=1e-4,
include_top=True,
weights=None,
input_tensor=None,
pooling=None,
**kwargs):
return SEResNet(input_shape,
depth=[3, 6, 23, 3],
width=width,
bottleneck=bottleneck,
weight_decay=weight_decay,
include_top=include_top,
weights=weights,
input_tensor=input_tensor,
pooling=pooling,
num_outputs=num_outputs,
**kwargs)
def SEResNet154(input_shape=None,
num_outputs=1000,
width=1,
bottleneck=True,
weight_decay=1e-4,
include_top=True,
weights=None,
input_tensor=None,
pooling=None,
**kwargs):
return SEResNet(input_shape,
depth=[3, 8, 36, 3],
width=width,
bottleneck=bottleneck,
weight_decay=weight_decay,
include_top=include_top,
weights=weights,
input_tensor=input_tensor,
pooling=pooling,
num_outputs=num_outputs,
**kwargs)
def _resnet_block(input, filters, k=1, strides=(1, 1, 1)):
''' Adds a pre-activation encoder block without bottleneck layers
Args:
input: input tensor
filters: number of output filters
k: width factor
strides: strides of the convolution layer
Returns: a keras tensor
'''
init = input
channel_axis = 1 if K.image_data_format() == "channels_first" else -1
x = BatchNormalization(axis=channel_axis)(input)
x = Activation('relu')(x)
if strides != (1, 1, 1) or init._keras_shape[channel_axis] != filters * k:
init = Conv3D(filters * k, (1, 1, 1), padding='same', kernel_initializer='he_normal',
use_bias=False, strides=strides)(x)
x = Conv3D(filters * k, (3, 3, 3), padding='same', kernel_initializer='he_normal',
use_bias=False, strides=strides)(x)
x = BatchNormalization(axis=channel_axis)(x)
x = Activation('relu')(x)
x = Conv3D(filters * k, (3, 3, 3), padding='same', kernel_initializer='he_normal',
use_bias=False)(x)
# squeeze and excite block
x = squeeze_excite_block(x)
m = add([x, init])
return m
def _resnet_bottleneck_block(input, filters, k=1, strides=(1, 1)):
''' Adds a pre-activation encoder block with bottleneck layers
Args:
input: input tensor
filters: number of output filters
k: width factor
strides: strides of the convolution layer
Returns: a keras tensor
'''
init = input
channel_axis = 1 if K.image_data_format() == "channels_first" else -1
bottleneck_expand = 4
x = BatchNormalization(axis=channel_axis)(input)
x = Activation('relu')(x)
if strides != (1, 1, 1) or init._keras_shape[channel_axis] != bottleneck_expand * filters * k:
init = Conv3D(bottleneck_expand * filters * k, (1, 1), padding='same', kernel_initializer='he_normal',
use_bias=False, strides=strides)(x)
x = Conv3D(filters * k, (1, 1, 1), padding='same', kernel_initializer='he_normal',
use_bias=False)(x)
x = BatchNormalization(axis=channel_axis)(x)
x = Activation('relu')(x)
x = Conv3D(filters * k, (3, 3, 3), padding='same', kernel_initializer='he_normal',
use_bias=False, strides=strides)(x)
x = BatchNormalization(axis=channel_axis)(x)
x = Activation('relu')(x)
x = Conv3D(bottleneck_expand * filters * k, (1, 1, 1), padding='same', kernel_initializer='he_normal',
use_bias=False)(x)
# squeeze and excite block
x = squeeze_excite_block(x)
m = add([x, init])
return m
def _create_se_resnet(num_outputs, img_input, include_top, initial_conv_filters, filters,
depth, width, bottleneck, weight_decay, pooling, activation="softmax",
padding="same"):
"""Creates a SE ResNet model with specified parameters
Args:
initial_conv_filters: number of features for the initial convolution
include_top: Flag to include the last fc layer
filters: number of filters per block, defined as a list.
filters = [64, 128, 256, 512
depth: number or layers in the each block, defined as a list.
ResNet-50 = [3, 4, 6, 3]
ResNet-101 = [3, 6, 23, 3]
ResNet-152 = [3, 8, 36, 3]
width: width multiplier for network (for Wide ResNet)
bottleneck: adds a bottleneck conv to reduce computation
weight_decay: weight_decay (l2 norm)
pooling: Optional pooling mode for feature extraction
when `include_top` is `False`.
- `None` means that the output of the model will be
the 4D tensor output of the
last convolutional layer.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional layer, and thus
the output of the model will be a 3D tensor.
- `max` means that global max pooling will
be applied.
Returns: a Keras Model
"""
channel_axis = 1 if K.image_data_format() == 'channels_first' else -1
N = list(depth)
# block 1 (initial conv block)
x = Conv3D(initial_conv_filters, (7, 7, 7), padding=padding, use_bias=False, strides=(2, 2, 2),
kernel_initializer='he_normal', kernel_regularizer=l2(weight_decay))(img_input)
x = MaxPooling3D((3, 3, 3), strides=(2, 2, 2), padding=padding)(x)
# block 2 (projection block)
for i in range(N[0]):
if bottleneck:
x = _resnet_bottleneck_block(x, filters[0], width)
else:
x = _resnet_block(x, filters[0], width)
# block 3 - N
for k in range(1, len(N)):
if bottleneck:
x = _resnet_bottleneck_block(x, filters[k], width, strides=(2, 2, 2))
else:
x = _resnet_block(x, filters[k], width, strides=(2, 2, 2))
for i in range(N[k] - 1):
if bottleneck:
x = _resnet_bottleneck_block(x, filters[k], width)
else:
x = _resnet_block(x, filters[k], width)
x = BatchNormalization(axis=channel_axis)(x)
x = Activation('relu')(x)
if include_top:
x = GlobalAveragePooling3D()(x)
x = Dense(num_outputs, use_bias=False, kernel_regularizer=l2(weight_decay),
activation=activation)(x)
else:
if pooling == 'avg':
x = GlobalAveragePooling3D()(x)
elif pooling == 'max':
x = GlobalMaxPooling3D()(x)
return x
class SEResnetBuilder(object):
@staticmethod
def build_se_resnet_18(*args, **kwargs):
return SEResNet18(*args, **kwargs)
@staticmethod
def build_se_resnet_34(*args, **kwargs):
return SEResNet34(*args, **kwargs)
@staticmethod
def build_se_resnet_50(*args, **kwargs):
return SEResNet50(*args, **kwargs)
@staticmethod
def build_se_resnet_101(*args, **kwargs):
return SEResNet101(*args, **kwargs)
@staticmethod
def build_se_resnet_154(*args, **kwargs):
return SEResNet154(*args, **kwargs)
| 15,245 | 35.561151 | 110 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/models/keras/senet/se.py | from keras.layers import GlobalAveragePooling3D, Reshape, Dense, multiply, add, Permute, Conv3D
from keras import backend as K
def squeeze_excite_block(input, ratio=16):
''' Create a channel-wise squeeze-excite block
Args:
input: input tensor
filters: number of output filters
Returns: a keras tensor
References
- [Squeeze and Excitation Networks](https://arxiv.org/abs/1709.01507)
'''
init = input
channel_axis = 1 if K.image_data_format() == "channels_first" else -1
filters = init._keras_shape[channel_axis]
se_shape = (1, 1, 1, filters)
se = GlobalAveragePooling3D()(init)
se = Reshape(se_shape)(se)
se = Dense(filters // ratio, activation='relu', kernel_initializer='he_normal', use_bias=False)(se)
se = Dense(filters, activation='sigmoid', kernel_initializer='he_normal', use_bias=False)(se)
if K.image_data_format() == 'channels_first':
se = Permute((4, 1, 2, 3))(se)
x = multiply([init, se])
return x
def spatial_squeeze_excite_block(input):
''' Create a spatial squeeze-excite block
Args:
input: input tensor
Returns: a keras tensor
References
- [Concurrent Spatial and Channel Squeeze & Excitation in Fully Convolutional Networks](https://arxiv.org/abs/1803.02579)
'''
se = Conv3D(1, (1, 1, 1), activation='sigmoid', use_bias=False,
kernel_initializer='he_normal')(input)
x = multiply([input, se])
return x
def channel_spatial_squeeze_excite(input, ratio=16):
''' Create a spatial squeeze-excite block
Args:
input: input tensor
filters: number of output filters
Returns: a keras tensor
References
- [Squeeze and Excitation Networks](https://arxiv.org/abs/1709.01507)
- [Concurrent Spatial and Channel Squeeze & Excitation in Fully Convolutional Networks](https://arxiv.org/abs/1803.02579)
'''
cse = squeeze_excite_block(input, ratio)
sse = spatial_squeeze_excite_block(input)
x = add([cse, sse])
return x
| 2,058 | 27.205479 | 127 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/models/keras/resnet/resnet.py | from __future__ import division
import six
from keras.models import Model
from keras.layers import (
Input,
Activation,
Dense,
Flatten
)
from keras.layers.convolutional import (
Conv3D,
MaxPooling3D,
AveragePooling3D
)
from keras.layers.merge import add
from keras.layers.normalization import BatchNormalization
from keras.regularizers import l2
from keras import backend as K
from keras.metrics import mean_absolute_error
import keras
def sensitivity(y_true, y_pred):
true_positives = keras.backend.sum(keras.backend.round(keras.backend.clip(y_true * y_pred, 0, 1)))
possible_positives = keras.backend.sum(keras.backend.round(keras.backend.clip(y_true, 0, 1)))
return true_positives / (possible_positives + keras.backend.epsilon())
def specificity(y_true, y_pred):
true_negatives = keras.backend.sum(keras.backend.round(keras.backend.clip((1-y_true) * (1-y_pred), 0, 1)))
possible_negatives = keras.backend.sum(keras.backend.round(keras.backend.clip(1-y_true, 0, 1)))
return true_negatives / (possible_negatives + keras.backend.epsilon())
def j_stat(y_true, y_pred):
return sensitivity(y_true, y_pred) + specificity(y_true, y_pred) - 1
def compare_scores(y_true, y_pred, comparison=0, metric=mean_absolute_error):
keras_comparison = keras.backend.variable(comparison)
return metric(y_true, y_pred) - metric(y_true, keras_comparison)
def _bn_relu(input):
"""Helper to build a BN -> relu block
"""
norm = BatchNormalization(axis=4)(input)
return Activation("relu")(norm)
def _conv_bn_relu(**conv_params):
"""Helper to build a conv -> BN -> relu block
"""
filters = conv_params["filters"]
kernel_size = conv_params["kernel_size"]
strides = conv_params.setdefault("strides", (1, 1, 1))
kernel_initializer = conv_params.setdefault("kernel_initializer", "he_normal")
padding = conv_params.setdefault("padding", "same")
kernel_regularizer = conv_params.setdefault("kernel_regularizer", l2(1.e-4))
def f(input):
conv = Conv3D(filters=filters, kernel_size=kernel_size,
strides=strides, padding=padding,
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer)(input)
return _bn_relu(conv)
return f
def _bn_relu_conv(**conv_params):
"""Helper to build a BN -> relu -> conv block.
This is an improved scheme proposed in http://arxiv.org/pdf/1603.05027v2.pdf
"""
filters = conv_params["filters"]
kernel_size = conv_params["kernel_size"]
strides = conv_params.setdefault("strides", (1, 1, 1))
kernel_initializer = conv_params.setdefault("kernel_initializer", "he_normal")
padding = conv_params.setdefault("padding", "same")
kernel_regularizer = conv_params.setdefault("kernel_regularizer", l2(1.e-4))
def f(input):
activation = _bn_relu(input)
return Conv3D(filters=filters, kernel_size=kernel_size,
strides=strides, padding=padding,
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer)(activation)
return f
def _shortcut(input, residual):
"""Adds a shortcut between input and residual block and merges them with "sum"
"""
# Expand channels of shortcut to match residual.
# Stride appropriately to match residual (width, height)
# Should be int if network architecture is correctly configured.
input_shape = K.int_shape(input)
residual_shape = K.int_shape(residual)
stride_width = int(round(input_shape[1] / residual_shape[1]))
stride_height = int(round(input_shape[2] / residual_shape[2]))
stride_depth = int(round(input_shape[3] / residual_shape[3]))
equal_channels = input_shape[4] == residual_shape[4]
shortcut = input
# 1 X 1 conv if reduced_shape is different. Else identity.
if stride_width > 1 or stride_height > 1 or not equal_channels:
shortcut = Conv3D(filters=residual_shape[4],
kernel_size=(1, 1, 1),
strides=(stride_width, stride_height, stride_depth),
padding="valid",
kernel_initializer="he_normal",
kernel_regularizer=l2(0.0001))(input)
return add([shortcut, residual])
def _residual_block(block_function, filters, repetitions, is_first_layer=False):
"""Builds a residual block with repeating bottleneck blocks.
"""
def f(input):
for i in range(repetitions):
init_strides = (1, 1, 1)
if i == 0 and not is_first_layer:
init_strides = (2, 2, 2)
input = block_function(filters=filters, init_strides=init_strides,
is_first_block_of_first_layer=(is_first_layer and i == 0))(input)
return input
return f
def basic_block(filters, init_strides=(1, 1, 1), is_first_block_of_first_layer=False):
"""Basic 3 X 3 convolution blocks for use on resnets with layers <= 34.
Follows improved proposed scheme in http://arxiv.org/pdf/1603.05027v2.pdf
"""
def f(input):
if is_first_block_of_first_layer:
# don't repeat bn->relu since we just did bn->relu->maxpool
conv1 = Conv3D(filters=filters, kernel_size=(3, 3, 3),
strides=init_strides,
padding="same",
kernel_initializer="he_normal",
kernel_regularizer=l2(1e-4))(input)
else:
conv1 = _bn_relu_conv(filters=filters, kernel_size=(3, 3, 3),
strides=init_strides)(input)
residual = _bn_relu_conv(filters=filters, kernel_size=(3, 3, 3))(conv1)
return _shortcut(input, residual)
return f
def bottleneck(filters, init_strides=(1, 1, 1), is_first_block_of_first_layer=False):
"""Bottleneck architecture for > 34 layer encoder.
Follows improved proposed scheme in http://arxiv.org/pdf/1603.05027v2.pdf
Returns:
adjacency_matrix final conv layer of filters * 4
"""
def f(input):
if is_first_block_of_first_layer:
# don't repeat bn->relu since we just did bn->relu->maxpool
conv_1_1 = Conv3D(filters=filters, kernel_size=(1, 1, 1),
strides=init_strides,
padding="same",
kernel_initializer="he_normal",
kernel_regularizer=l2(1e-4))(input)
else:
conv_1_1 = _bn_relu_conv(filters=filters, kernel_size=(1, 1, 1),
strides=init_strides)(input)
conv_3_3 = _bn_relu_conv(filters=filters, kernel_size=(3, 3, 3))(conv_1_1)
residual = _bn_relu_conv(filters=filters * 4, kernel_size=(1, 1, 1))(conv_3_3)
return _shortcut(input, residual)
return f
def _get_block(identifier):
if isinstance(identifier, six.string_types):
res = globals().get(identifier)
if not res:
raise ValueError('Invalid {}'.format(identifier))
return res
return identifier
class ResnetBuilder(object):
@staticmethod
def build(input_shape, num_outputs, block_fn, repetitions, activation="softmax", kernel_initializer='he_normal',
n_dense_layers=1):
"""Builds a custom ResNet like architecture.
Args:
input_shape: The input reduced_shape in the form (nb_rows, nb_cols, nb_z_cols, nb_channels)
num_outputs: The number of outputs at final activation layer
block_fn: The block function to use. This is either `basic_block` or `bottleneck`.
The original paper used basic_block for layers < 50
repetitions: Number of repetitions of various block units.
At each block unit, the number of filters are doubled and the input size is halved
activation: default is 'softmax'
kernel_initializer: default is 'he_normal'
Returns:
The keras `Model`.
"""
# Load function from str if needed.
block_fn = _get_block(block_fn)
input = Input(shape=input_shape)
conv1 = _conv_bn_relu(filters=64, kernel_size=(7, 7, 7), strides=(2, 2, 2))(input)
pool1 = MaxPooling3D(pool_size=(3, 3, 3), strides=(2, 2, 2), padding="same")(conv1)
block = pool1
filters = 64
for i, r in enumerate(repetitions):
block = _residual_block(block_fn, filters=filters, repetitions=r, is_first_layer=(i == 0))(block)
filters *= 2
# Last activation
block = _bn_relu(block)
# Classifier block
block_shape = K.int_shape(block)
pool2 = AveragePooling3D(pool_size=(block_shape[1], block_shape[2], block_shape[3]),
strides=(1, 1, 1))(block)
flatten1 = Flatten()(pool2)
dense_input = flatten1
for i in range(n_dense_layers):
if (i + 1) < n_dense_layers:
layer_activation = None
else:
layer_activation = activation
dense_input = Dense(units=num_outputs,
kernel_initializer=kernel_initializer,
activation=layer_activation)(dense_input)
model = Model(inputs=input, outputs=dense_input)
return model
@staticmethod
def build_resnet_18(input_shape, num_outputs, **kwargs):
return ResnetBuilder.build(input_shape, num_outputs, basic_block, [2, 2, 2, 2], **kwargs)
@staticmethod
def build_resnet_34(input_shape, num_outputs, **kwargs):
return ResnetBuilder.build(input_shape, num_outputs, basic_block, [3, 4, 6, 3], **kwargs)
@staticmethod
def build_resnet_50(input_shape, num_outputs, **kwargs):
return ResnetBuilder.build(input_shape, num_outputs, bottleneck, [3, 4, 6, 3], **kwargs)
@staticmethod
def build_resnet_101(input_shape, num_outputs, **kwargs):
return ResnetBuilder.build(input_shape, num_outputs, bottleneck, [3, 4, 23, 3], **kwargs)
@staticmethod
def build_resnet_152(input_shape, num_outputs, **kwargs):
return ResnetBuilder.build(input_shape, num_outputs, bottleneck, [3, 8, 36, 3], **kwargs)
| 10,397 | 38.090226 | 116 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/models/pytorch/build.py | import os
import math
import torch
import torch.nn
from .classification import resnet
from .classification import custom
from .segmentation import unet
from . import graph
def fetch_model_by_name(model_name, *args, **kwargs):
try:
if "res" in model_name.lower():
return getattr(resnet, model_name)(*args, **kwargs)
elif "graph" in model_name.lower():
return getattr(graph, model_name)(*args, **kwargs)
elif "unet" in model_name.lower():
return getattr(unet, model_name)(*args, **kwargs)
else:
return getattr(custom, model_name)(*args, **kwargs)
except AttributeError:
raise ValueError("model name {} not supported".format(model_name))
def build_or_load_model(model_name, model_filename, n_features, n_outputs, n_gpus=0, bias=None, freeze_bias=False,
strict=False, **kwargs):
model = fetch_model_by_name(model_name, n_features=n_features, n_outputs=n_outputs, **kwargs)
if bias is not None:
model.fc.bias = torch.nn.Parameter(torch.from_numpy(bias))
if freeze_bias:
model.fc.bias.requires_grad_(False)
if n_gpus > 1:
model = model.cuda()
model = torch.nn.DataParallel(model).cuda()
elif n_gpus > 0:
model = model.cuda()
if os.path.exists(model_filename):
if n_gpus > 0:
state_dict = torch.load(model_filename)
else:
state_dict = torch.load(model_filename, map_location=torch.device('cpu'))
model = load_state_dict(model, state_dict, n_gpus=n_gpus, strict=strict)
return model
def load_state_dict(model, state_dict, n_gpus, strict=False):
try:
if not strict:
state_dict = match_state_dict_shapes(model.state_dict(), state_dict)
model.load_state_dict(state_dict, strict=strict)
except RuntimeError as error:
if n_gpus > 1:
if not strict:
state_dict = match_state_dict_shapes(model.module.state_dict(), state_dict)
model.module.load_state_dict(state_dict, strict=strict)
else:
raise error
return model
def match_state_dict_shapes(fixed_state_dict, moving_state_dict):
for key in fixed_state_dict:
if key in moving_state_dict and fixed_state_dict[key].size() != moving_state_dict[key].size():
moving_state_dict[key] = match_tensor_sizes(fixed_state_dict[key], moving_state_dict[key])
return moving_state_dict
def match_tensor_sizes(fixed_tensor, moving_tensor):
fixed_tensor_size = fixed_tensor.size()
moving_tensor_size = moving_tensor.size()
for dim in range(len(moving_tensor_size)):
if fixed_tensor_size[dim] > moving_tensor_size[dim]:
moving_tensor = torch.cat([moving_tensor] *
int(math.ceil(fixed_tensor_size[dim] / moving_tensor_size[dim])),
dim=dim)
if fixed_tensor_size[dim] != moving_tensor_size[dim]:
moving_tensor = moving_tensor.narrow(dim=dim, start=0, length=fixed_tensor_size[dim])
return moving_tensor
| 3,130 | 38.1375 | 114 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/models/pytorch/classification/custom.py | from torch import nn
from unet3d.models.pytorch.autoencoder.variational import VariationalAutoEncoder
from .decoder import BasicDecoder, Decoder1D
from .resnet import conv1x1x1, ResNet, BasicBlock
class RegularizedResNet(VariationalAutoEncoder):
def __init__(self, n_outputs, *args, **kwargs):
super(RegularizedResNet, self).__init__(*args, **kwargs)
self.fc = nn.Linear(self.var_layer.in_size, n_outputs)
def forward(self, x):
x = self.encoder(x)
x = self.var_layer.in_conv(x).flatten(start_dim=1)
output = self.fc(x)
x, mu, logvar = self.var_layer.var_block(x)
x = self.var_layer.relu(x).view(-1, *self.var_layer.reduced_shape)
x = self.var_layer.out_conv(x)
x = self.var_layer.upsample(x)
x = self.decoder(x)
vae_output = self.final_convolution(x)
return output, vae_output, mu, logvar
class RegularizedBasicResNet(nn.Module):
def __init__(self, n_features, upsampling_mode="trilinear", upsampling_scale=2, plane_dilation=2,
decoding_layers=None, latent_planes=512, layer_block=BasicBlock, **encoder_kwargs):
super(RegularizedBasicResNet, self).__init__()
if decoding_layers is None:
decoding_layers = [1, 1, 1, 1, 1, 1, 1]
self.encoder = _ResNetLatent(block=layer_block, n_features=n_features, **encoder_kwargs)
self.decoder = BasicDecoder(upsampling_scale=upsampling_scale, upsampling_mode=upsampling_mode,
plane_dilation=plane_dilation, layers=decoding_layers, in_planes=latent_planes,
block=layer_block)
out_decoder_planes = int(latent_planes/(plane_dilation**len(decoding_layers)))
self.final_convolution = conv1x1x1(in_planes=out_decoder_planes, out_planes=n_features, stride=1)
def forward(self, x):
out, x = self.encoder(x)
x = self.decoder(x)
x = self.final_convolution(x)
return out, x
class _ResNetLatent(ResNet):
def forward(self, x):
x = self.conv1(x)
x = self.bn1(x)
x = self.relu(x)
x = self.maxpool(x)
x = self.layer1(x)
x = self.layer2(x)
x = self.layer3(x)
x = self.layer4(x)
x = self.avgpool(x)
latent = x
x = x.reshape(x.size(0), -1)
x = self.fc(x)
return x, latent
class ResNetWithDecoder1D(nn.Module):
def __init__(self, n_fc_outputs, n_outputs, initial_upsample=1024, blocks_per_layer=1, channel_decay=2,
upsample_factor=2, resnet_block=BasicBlock, interpolation_mode="linear",
interpolation_align_corners=True, **kwargs):
super(ResNetWithDecoder1D, self).__init__()
self.encoder = ResNet(n_outputs=n_fc_outputs, block=resnet_block, **kwargs)
self.initial_upsample = initial_upsample
_size = initial_upsample
_channels = n_fc_outputs
layer_blocks = list()
layer_channels = list()
while _size < n_outputs:
_size = int(_size * upsample_factor)
_channels = int(_channels/channel_decay)
layer_blocks.append(blocks_per_layer)
layer_channels.append(_channels)
self.decoder = Decoder1D(input_features=n_fc_outputs, output_features=n_outputs, layer_blocks=layer_blocks,
layer_channels=layer_channels, upsample_factor=upsample_factor,
interpolation_mode=interpolation_mode,
interpolation_align_corners=interpolation_align_corners)
self.out_conv = nn.Conv1d(in_channels=layer_channels[-1], out_channels=1, kernel_size=3, bias=False)
self.output_features = n_outputs
self.interpolation_mode = interpolation_mode
self.interpolation_align_corners = interpolation_align_corners
def forward(self, x):
x = self.encoder(x)
x = nn.functional.interpolate(x.flatten(start_dim=1)[..., None], size=(self.initial_upsample,))
x = self.decoder(x)
x = self.out_conv(x)
return nn.functional.interpolate(x,
size=(self.output_features,),
mode=self.interpolation_mode,
align_corners=self.interpolation_align_corners)
| 4,384 | 43.292929 | 115 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/models/pytorch/classification/resnet.py | """
Modified from https://github.com/pytorch/vision/blob/master/torchvision/models/resnet.py
"""
import torch.nn as nn
__all__ = ['ResNet', 'resnet_18', 'resnet_34', 'resnet_50', 'resnet_101',
'resnet_152', 'resnext_50_32x4d', 'resnext_101_32x8d', 'conv3x3x3',
'conv1x1x1']
def conv3x3x3(in_planes, out_planes, stride=1, groups=1, padding=None, dilation=1, kernel_size=3):
"""3x3x3 convolution with padding"""
if padding is None:
padding = kernel_size // 2 # padding to keep the image size constant
return nn.Conv3d(in_planes, out_planes, kernel_size=kernel_size, stride=stride,
padding=padding, groups=groups, bias=False, dilation=dilation)
def conv1x1x1(in_planes, out_planes, stride=1):
"""1x1x1 convolution"""
return nn.Conv3d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
class BasicBlock(nn.Module):
expansion = 1
def __init__(self, in_planes, planes, stride=1, downsample=None, groups=1,
base_width=64, dilation=1, norm_layer=None):
super(BasicBlock, self).__init__()
if norm_layer is None:
self.norm_layer = nn.BatchNorm3d
else:
self.norm_layer = norm_layer
if groups != 1 or base_width != 64:
raise ValueError('BasicBlock only supports groups=1 and base_width=64')
if dilation > 1:
raise NotImplementedError("Dilation > 1 not supported in BasicBlock")
# Both self.conv1 and self.downsample layers downsample the input when stride != 1
self.conv1 = conv3x3x3(in_planes, planes, stride)
self.bn1 = self.create_norm_layer(planes)
self.relu = nn.ReLU(inplace=True)
self.conv2 = conv3x3x3(planes, planes)
self.bn2 = self.create_norm_layer(planes)
self.downsample = downsample
self.stride = stride
def forward(self, x):
identity = x
out = self.conv1(x)
out = self.bn1(out)
out = self.relu(out)
out = self.conv2(out)
out = self.bn2(out)
if self.downsample is not None:
identity = self.downsample(x)
out += identity
out = self.relu(out)
return out
def create_norm_layer(self, *args, **kwargs):
return self.norm_layer(*args, **kwargs)
class BasicBlock1D(BasicBlock):
def __init__(self, in_channels, channels, stride=1, downsample=None, kernel_size=3, norm_layer=None):
super(BasicBlock, self).__init__()
if norm_layer is None:
self.norm_layer = nn.BatchNorm1d
else:
self.norm_layer = norm_layer
self.conv1 = nn.Conv1d(in_channels=in_channels, out_channels=channels, stride=stride, kernel_size=kernel_size,
bias=False, padding=1)
self.bn1 = self.create_norm_layer(channels)
self.relu = nn.ReLU(inplace=True)
self.conv2 = nn.Conv1d(in_channels=channels, out_channels=channels, stride=stride, kernel_size=kernel_size,
bias=False, padding=1)
self.bn2 = self.create_norm_layer(channels)
self.downsample = downsample
self.stride = stride
class Bottleneck(nn.Module):
expansion = 4
def __init__(self, in_planes, planes, stride=1, downsample=None, groups=1,
base_width=64, dilation=1, norm_layer=None):
super(Bottleneck, self).__init__()
if norm_layer is None:
self.norm_layer = nn.BatchNorm3d
else:
self.norm_layer = norm_layer
width = int(planes * (base_width / 64.)) * groups
# Both self.conv2 and self.downsample layers downsample the input when stride != 1
self.conv1 = conv1x1x1(in_planes, width)
self.bn1 = self.create_norm_layer(width)
self.conv2 = conv3x3x3(width, width, stride, groups, dilation)
self.bn2 = self.create_norm_layer(width)
self.conv3 = conv1x1x1(width, planes * self.expansion)
self.bn3 = self.create_norm_layer(planes * self.expansion)
self.relu = nn.ReLU(inplace=True)
self.downsample = downsample
self.stride = stride
def forward(self, x):
identity = x
out = self.conv1(x)
out = self.bn1(out)
out = self.relu(out)
out = self.conv2(out)
out = self.bn2(out)
out = self.relu(out)
out = self.conv3(out)
out = self.bn3(out)
if self.downsample is not None:
identity = self.downsample(x)
out += identity
out = self.relu(out)
return out
def create_norm_layer(self, *args, **kwargs):
return self.norm_layer(*args, **kwargs)
class ResNet(nn.Module):
def __init__(self, block, layers, n_outputs=1000, zero_init_residual=False,
groups=1, width_per_group=64, replace_stride_with_dilation=None,
norm_layer=None, n_features=3):
super(ResNet, self).__init__()
if norm_layer is None:
norm_layer = nn.BatchNorm3d
self._norm_layer = norm_layer
self.in_planes = 64
self.dilation = 1
if replace_stride_with_dilation is None:
# each element in the tuple indicates if we should replace
# the 2x2x2 stride with a dilated convolution instead
replace_stride_with_dilation = [False, False, False]
if len(replace_stride_with_dilation) != 3:
raise ValueError("replace_stride_with_dilation should be None "
"or a 3-element tuple, got {}".format(replace_stride_with_dilation))
self.groups = groups
self.base_width = width_per_group
self.conv1 = nn.Conv3d(n_features, self.in_planes, kernel_size=7, stride=2, padding=3,
bias=False)
self.bn1 = norm_layer(self.in_planes)
self.relu = nn.ReLU(inplace=True)
self.maxpool = nn.MaxPool3d(kernel_size=3, stride=2, padding=1)
self.layer1 = self._make_layer(block, 64, layers[0])
self.layer2 = self._make_layer(block, 128, layers[1], stride=2,
dilate=replace_stride_with_dilation[0])
self.layer3 = self._make_layer(block, 256, layers[2], stride=2,
dilate=replace_stride_with_dilation[1])
self.layer4 = self._make_layer(block, 512, layers[3], stride=2,
dilate=replace_stride_with_dilation[2])
self.avgpool = nn.AdaptiveAvgPool3d(1)
self.fc = nn.Linear(512 * block.expansion, n_outputs)
for m in self.modules():
if isinstance(m, nn.Conv3d):
nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
elif isinstance(m, (nn.BatchNorm3d, nn.GroupNorm)):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
# Zero-initialize the last BN in each residual branch,
# so that the residual branch starts with zeros, and each residual block behaves like an identity.
# This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
if zero_init_residual:
for m in self.modules():
if isinstance(m, Bottleneck):
nn.init.constant_(m.bn3.weight, 0)
elif isinstance(m, BasicBlock):
nn.init.constant_(m.bn2.weight, 0)
def _make_layer(self, block, planes, blocks, stride=1, dilate=False):
norm_layer = self._norm_layer
downsample = None
previous_dilation = self.dilation
if dilate:
self.dilation *= stride
stride = 1
if stride != 1 or self.in_planes != planes * block.expansion:
downsample = nn.Sequential(
conv1x1x1(self.in_planes, planes * block.expansion, stride),
norm_layer(planes * block.expansion),
)
layers = []
layers.append(block(self.in_planes, planes, stride, downsample, self.groups,
self.base_width, previous_dilation, norm_layer))
self.in_planes = planes * block.expansion
for _ in range(1, blocks):
layers.append(block(self.in_planes, planes, groups=self.groups,
base_width=self.base_width, dilation=self.dilation,
norm_layer=norm_layer))
return nn.Sequential(*layers)
def forward(self, x):
x = self.conv1(x)
x = self.bn1(x)
x = self.relu(x)
x = self.maxpool(x)
x = self.layer1(x)
x = self.layer2(x)
x = self.layer3(x)
x = self.layer4(x)
x = self.avgpool(x)
x = x.reshape(x.size(0), -1)
x = self.fc(x)
return x
def _resnet(arch, block, layers, pretrained, progress, **kwargs):
model = ResNet(block, layers, **kwargs)
return model
def resnet_18(pretrained=False, progress=True, **kwargs):
"""Constructs a ResNet-18 model.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
progress (bool): If True, displays a progress bar of the download to stderr
"""
return _resnet('resnet_18', BasicBlock, [2, 2, 2, 2], pretrained, progress,
**kwargs)
def resnet_34(pretrained=False, progress=True, **kwargs):
"""Constructs a ResNet-34 model.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
progress (bool): If True, displays a progress bar of the download to stderr
"""
return _resnet('resnet_34', BasicBlock, [3, 4, 6, 3], pretrained, progress,
**kwargs)
def resnet_50(pretrained=False, progress=True, **kwargs):
"""Constructs a ResNet-50 model.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
progress (bool): If True, displays a progress bar of the download to stderr
"""
return _resnet('resnet_50', Bottleneck, [3, 4, 6, 3], pretrained, progress,
**kwargs)
def resnet_101(pretrained=False, progress=True, **kwargs):
"""Constructs a ResNet-101 model.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
progress (bool): If True, displays a progress bar of the download to stderr
"""
return _resnet('resnet_101', Bottleneck, [3, 4, 23, 3], pretrained, progress,
**kwargs)
def resnet_152(pretrained=False, progress=True, **kwargs):
"""Constructs a ResNet-152 model.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
progress (bool): If True, displays a progress bar of the download to stderr
"""
return _resnet('resnet_152', Bottleneck, [3, 8, 36, 3], pretrained, progress,
**kwargs)
def resnext_50_32x4d(pretrained=False, progress=True, **kwargs):
"""Constructs a ResNeXt-50 32x4d model.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
progress (bool): If True, displays a progress bar of the download to stderr
"""
kwargs['groups'] = 32
kwargs['width_per_group'] = 4
return _resnet('resnext_50_32x4d', Bottleneck, [3, 4, 6, 3],
pretrained, progress, **kwargs)
def resnext_101_32x8d(pretrained=False, progress=True, **kwargs):
"""Constructs a ResNeXt-101 32x8d model.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
progress (bool): If True, displays a progress bar of the download to stderr
"""
kwargs['groups'] = 32
kwargs['width_per_group'] = 8
return _resnet('resnext_101_32x8d', Bottleneck, [3, 4, 23, 3],
pretrained, progress, **kwargs)
| 11,846 | 36.729299 | 118 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/models/pytorch/classification/decoder.py | from functools import partial
from torch import nn
from .myronenko import MyronenkoLayer, MyronenkoResidualBlock
from . import resnet
class BasicDecoder(nn.Module):
def __init__(self, in_planes, layers, block=resnet.BasicBlock, plane_dilation=2, upsampling_mode="trilinear",
upsampling_scale=2):
super(BasicDecoder, self).__init__()
self.layers = nn.ModuleList()
self.conv1s = nn.ModuleList()
self.upsampling_mode = upsampling_mode
self.upsampling_scale = upsampling_scale
layer_planes = in_planes
for n_blocks in layers:
self.conv1s.append(resnet.conv1x1x1(in_planes=layer_planes,
out_planes=int(layer_planes/plane_dilation)))
layer = nn.ModuleList()
layer_planes = int(layer_planes/plane_dilation)
for i_block in range(n_blocks):
layer.append(block(layer_planes, layer_planes))
self.layers.append(layer)
def forward(self, x):
for conv1, layer in zip(self.conv1s, self.layers):
x = conv1(x)
x = nn.functional.interpolate(x, scale_factor=self.upsampling_scale, mode=self.upsampling_mode)
for block in layer:
x = block(x)
return x
class MyronenkoDecoder(nn.Module):
def __init__(self, base_width=32, layer_blocks=None, layer=MyronenkoLayer, block=MyronenkoResidualBlock,
upsampling_scale=2, feature_reduction_scale=2, upsampling_mode="trilinear", align_corners=False,
layer_widths=None, use_transposed_convolutions=False, kernal_size=3):
super(MyronenkoDecoder, self).__init__()
if layer_blocks is None:
layer_blocks = [1, 1, 1]
self.layers = nn.ModuleList()
self.pre_upsampling_blocks = nn.ModuleList()
self.upsampling_blocks = list()
for i, n_blocks in enumerate(layer_blocks):
depth = len(layer_blocks) - (i + 1)
if layer_widths is not None:
out_width = layer_widths[depth]
in_width = layer_widths[depth + 1]
else:
out_width = base_width * (feature_reduction_scale ** depth)
in_width = out_width * feature_reduction_scale
if use_transposed_convolutions:
self.pre_upsampling_blocks.append(resnet.conv1x1x1(in_width, out_width, stride=1))
self.upsampling_blocks.append(partial(nn.functional.interpolate, scale_factor=upsampling_scale,
mode=upsampling_mode, align_corners=align_corners))
else:
self.pre_upsampling_blocks.append(nn.Sequential())
self.upsampling_blocks.append(nn.ConvTranspose3d(in_width, out_width, kernel_size=kernal_size,
stride=upsampling_scale, padding=1))
self.layers.append(layer(n_blocks=n_blocks, block=block, in_planes=out_width, planes=out_width,
kernal_size=kernal_size))
def forward(self, x):
for pre, up, lay in zip(self.pre_upsampling_blocks, self.upsampling_blocks, self.layers):
x = pre(x)
x = up(x)
x = lay(x)
return x
class MirroredDecoder(nn.Module):
def __init__(self, base_width=32, layer_blocks=None, layer=MyronenkoLayer, block=MyronenkoResidualBlock,
upsampling_scale=2, feature_reduction_scale=2, upsampling_mode="trilinear", align_corners=False,
layer_widths=None, use_transposed_convolutions=False, kernel_size=3):
super(MirroredDecoder, self).__init__()
self.use_transposed_convolutions = use_transposed_convolutions
if layer_blocks is None:
self.layer_blocks = [1, 1, 1, 1]
else:
self.layer_blocks = layer_blocks
self.layers = nn.ModuleList()
self.pre_upsampling_blocks = nn.ModuleList()
if use_transposed_convolutions:
self.upsampling_blocks = nn.ModuleList()
else:
self.upsampling_blocks = list()
self.base_width = base_width
self.feature_reduction_scale = feature_reduction_scale
self.layer_widths = layer_widths
for i, n_blocks in enumerate(self.layer_blocks):
depth = len(self.layer_blocks) - (i + 1)
in_width, out_width = self.calculate_layer_widths(depth)
if depth != 0:
self.layers.append(layer(n_blocks=n_blocks, block=block, in_planes=in_width, planes=in_width,
kernel_size=kernel_size))
if self.use_transposed_convolutions:
self.pre_upsampling_blocks.append(nn.Sequential())
self.upsampling_blocks.append(nn.ConvTranspose3d(in_width, out_width, kernel_size=kernel_size,
stride=upsampling_scale, padding=1))
else:
self.pre_upsampling_blocks.append(resnet.conv1x1x1(in_width, out_width, stride=1))
self.upsampling_blocks.append(partial(nn.functional.interpolate, scale_factor=upsampling_scale,
mode=upsampling_mode, align_corners=align_corners))
else:
self.layers.append(layer(n_blocks=n_blocks, block=block, in_planes=in_width, planes=out_width,
kernel_size=kernel_size))
def calculate_layer_widths(self, depth):
if self.layer_widths is not None:
out_width = self.layer_widths[depth]
in_width = self.layer_widths[depth + 1]
else:
if depth > 0:
out_width = int(self.base_width * (self.feature_reduction_scale ** (depth - 1)))
in_width = out_width * self.feature_reduction_scale
else:
out_width = self.base_width
in_width = self.base_width
return in_width, out_width
def forward(self, x):
for pre, up, lay in zip(self.pre_upsampling_blocks, self.upsampling_blocks, self.layers[:-1]):
x = lay(x)
x = pre(x)
x = up(x)
x = self.layers[-1](x)
return x
class Decoder1D(nn.Module):
def __init__(self, input_features, output_features, layer_blocks, layer_channels, block=resnet.BasicBlock1D,
kernel_size=3, upsample_factor=2, interpolation_mode="linear", interpolation_align_corners=True):
super(Decoder1D, self).__init__()
self.layers = nn.ModuleList()
self.conv1s = nn.ModuleList()
self.output_features = output_features
self.interpolation_mode = interpolation_mode
self.interpolation_align_corners = interpolation_align_corners
self.upsample_factor = upsample_factor
in_channels = input_features
for n_blocks, out_channels in zip(layer_blocks, layer_channels):
layer = nn.ModuleList()
self.conv1s.append(nn.Conv1d(in_channels=in_channels, out_channels=out_channels, kernel_size=1,
stride=1, bias=False))
for i_block in range(n_blocks):
layer.append(block(in_channels=out_channels, channels=out_channels, kernel_size=kernel_size, stride=1))
in_channels = out_channels
self.layers.append(layer)
def forward(self, x):
for (layer, conv1) in zip(self.layers, self.conv1s):
x = nn.functional.interpolate(x,
size=(x.shape[-1] * self.upsample_factor),
mode=self.interpolation_mode,
align_corners=self.interpolation_align_corners)
x = conv1(x)
for block in layer:
x = block(x)
return x
| 8,019 | 48.202454 | 119 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/models/pytorch/classification/myronenko.py | from torch import nn as nn
from .resnet import conv3x3x3, conv1x1x1
class MyronenkoConvolutionBlock(nn.Module):
def __init__(self, in_planes, planes, stride=1, norm_layer=None, norm_groups=8, kernel_size=3):
super(MyronenkoConvolutionBlock, self).__init__()
self.norm_groups = norm_groups
if norm_layer is None:
self.norm_layer = nn.GroupNorm
else:
self.norm_layer = norm_layer
self.norm1 = self.create_norm_layer(in_planes)
self.relu = nn.ReLU(inplace=True)
self.conv = conv3x3x3(in_planes, planes, stride, kernel_size=kernel_size)
def forward(self, x):
x = self.norm1(x)
x = self.relu(x)
x = self.conv(x)
return x
def create_norm_layer(self, planes, error_on_non_divisible_norm_groups=False):
if planes < self.norm_groups:
return self.norm_layer(planes, planes)
elif not error_on_non_divisible_norm_groups and (planes % self.norm_groups) > 0:
# This will just make a the number of norm groups equal to the number of planes
print("Setting number of norm groups to {} for this convolution block.".format(planes))
return self.norm_layer(planes, planes)
else:
return self.norm_layer(self.norm_groups, planes)
class MyronenkoResidualBlock(nn.Module):
def __init__(self, in_planes, planes, stride=1, norm_layer=None, norm_groups=8, kernel_size=3):
super(MyronenkoResidualBlock, self).__init__()
self.conv1 = MyronenkoConvolutionBlock(in_planes=in_planes, planes=planes, stride=stride,
norm_layer=norm_layer,
norm_groups=norm_groups, kernel_size=kernel_size)
self.conv2 = MyronenkoConvolutionBlock(in_planes=planes, planes=planes, stride=stride, norm_layer=norm_layer,
norm_groups=norm_groups, kernel_size=kernel_size)
if in_planes != planes:
self.sample = conv1x1x1(in_planes, planes)
else:
self.sample = None
def forward(self, x):
identity = x
x = self.conv1(x)
x = self.conv2(x)
if self.sample is not None:
identity = self.sample(identity)
x += identity
return x
class MyronenkoLayer(nn.Module):
def __init__(self, n_blocks, block, in_planes, planes, *args, dropout=None, kernel_size=3, **kwargs):
super(MyronenkoLayer, self).__init__()
self.block = block
self.n_blocks = n_blocks
self.blocks = nn.ModuleList()
for i in range(n_blocks):
self.blocks.append(block(in_planes, planes, *args, kernel_size=kernel_size, **kwargs))
in_planes = planes
if dropout is not None:
self.dropout = nn.Dropout3d(dropout, inplace=True)
else:
self.dropout = None
def forward(self, x):
for i, block in enumerate(self.blocks):
x = block(x)
if i == 0 and self.dropout is not None:
x = self.dropout(x)
return x
class MyronenkoEncoder(nn.Module):
def __init__(self, n_features, base_width=32, layer_blocks=None, layer=MyronenkoLayer, block=MyronenkoResidualBlock,
feature_dilation=2, downsampling_stride=2, dropout=0.2, layer_widths=None, kernel_size=3):
super(MyronenkoEncoder, self).__init__()
if layer_blocks is None:
layer_blocks = [1, 2, 2, 4]
self.layers = nn.ModuleList()
self.downsampling_convolutions = nn.ModuleList()
in_width = n_features
for i, n_blocks in enumerate(layer_blocks):
if layer_widths is not None:
out_width = layer_widths[i]
else:
out_width = base_width * (feature_dilation ** i)
if dropout and i == 0:
layer_dropout = dropout
else:
layer_dropout = None
self.layers.append(layer(n_blocks=n_blocks, block=block, in_planes=in_width, planes=out_width,
dropout=layer_dropout, kernel_size=kernel_size))
if i != len(layer_blocks) - 1:
self.downsampling_convolutions.append(conv3x3x3(out_width, out_width, stride=downsampling_stride,
kernel_size=kernel_size))
print("Encoder {}:".format(i), in_width, out_width)
in_width = out_width
def forward(self, x):
for layer, downsampling in zip(self.layers[:-1], self.downsampling_convolutions):
x = layer(x)
x = downsampling(x)
x = self.layers[-1](x)
return x
| 4,771 | 40.495652 | 120 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/models/pytorch/fcn/fcn.py | from torch import nn
class FCN(nn.Module):
def __init__(self, hidden_layers_list, n_inputs, n_outputs):
super().__init__()
_layers = list()
_n_inputs = n_inputs
for hidden_layer in hidden_layers_list:
_layer = nn.Linear(_n_inputs, hidden_layer)
_n_inputs = hidden_layer
_layers.append(_layer)
_layers.append(nn.ReLU())
_layers.append(nn.Linear(_n_inputs, n_outputs))
self.network = nn.Sequential(*_layers)
def forward(self, x):
return self.network(x)
| 566 | 28.842105 | 64 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/models/pytorch/segmentation/unet.py | import torch
from ..classification.myronenko import MyronenkoEncoder
from ..classification.decoder import MirroredDecoder
from ..autoencoder.variational import ConvolutionalAutoEncoder
class UNetEncoder(MyronenkoEncoder):
def forward(self, x):
outputs = list()
for layer, downsampling in zip(self.layers[:-1], self.downsampling_convolutions):
x = layer(x)
outputs.insert(0, x)
x = downsampling(x)
x = self.layers[-1](x)
outputs.insert(0, x)
return outputs
class UNetDecoder(MirroredDecoder):
def calculate_layer_widths(self, depth):
in_width, out_width = super().calculate_layer_widths(depth=depth)
if depth != len(self.layer_blocks) - 1:
in_width *= 2
print("Decoder {}:".format(depth), in_width, out_width)
return in_width, out_width
def forward(self, inputs):
x = inputs[0]
for i, (pre, up, lay) in enumerate(zip(self.pre_upsampling_blocks, self.upsampling_blocks, self.layers[:-1])):
x = lay(x)
x = pre(x)
x = up(x)
x = torch.cat((x, inputs[i + 1]), 1)
x = self.layers[-1](x)
return x
class UNet(ConvolutionalAutoEncoder):
def __init__(self, *args, encoder_class=UNetEncoder, decoder_class=UNetDecoder, n_outputs=1, **kwargs):
super().__init__(*args, encoder_class=encoder_class, decoder_class=decoder_class, n_outputs=n_outputs, **kwargs)
self.set_final_convolution(n_outputs=n_outputs)
class AutocastUNet(UNet):
def forward(self, *args, **kwargs):
from torch.cuda.amp import autocast
with autocast():
output = super().forward(*args, **kwargs)
return output
class AutoImplantUNet(UNet):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
def forward(self, x):
y = super(AutoImplantUNet, self).forward(x)
return y - x
def test(self, x):
return super(AutoImplantUNet, self).forward(x)
| 2,037 | 31.870968 | 120 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/models/pytorch/autoencoder/vqvae2.py | import torch
from torch import nn
from torch.nn import functional as F
# Copyright 2018 The Sonnet Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ============================================================================
# Borrowed from https://github.com/deepmind/sonnet and ported it to PyTorch
# Borrowed from https://github.com/rosinality/vq-vae-2-pytorch and converted to 3D
class Quantize(nn.Module):
def __init__(self, dim, n_embed, decay=0.99, eps=1e-5):
super().__init__()
self.dim = dim
self.n_embed = n_embed
self.decay = decay
self.eps = eps
embed = torch.randn(dim, n_embed)
self.register_buffer('embed', embed)
self.register_buffer('cluster_size', torch.zeros(n_embed))
self.register_buffer('embed_avg', embed.clone())
def forward(self, input):
flatten = input.reshape(-1, self.dim)
dist = (
flatten.pow(2).sum(1, keepdim=True)
- 2 * flatten @ self.embed
+ self.embed.pow(2).sum(0, keepdim=True)
)
_, embed_ind = (-dist).max(1)
embed_onehot = F.one_hot(embed_ind, self.n_embed).type(flatten.dtype)
embed_ind = embed_ind.view(*input.shape[:-1])
quantize = self.embed_code(embed_ind)
if self.training:
self.cluster_size.data.mul_(self.decay).add_(
1 - self.decay, embed_onehot.sum(0)
)
embed_sum = flatten.transpose(0, 1) @ embed_onehot
self.embed_avg.data.mul_(self.decay).add_(1 - self.decay, embed_sum)
n = self.cluster_size.sum()
cluster_size = (
(self.cluster_size + self.eps) / (n + self.n_embed * self.eps) * n
)
embed_normalized = self.embed_avg / cluster_size.unsqueeze(0)
self.embed.data.copy_(embed_normalized)
diff = (quantize.detach() - input).pow(2).mean()
quantize = input + (quantize - input).detach()
return quantize, diff, embed_ind
def embed_code(self, embed_id):
return F.embedding(embed_id, self.embed.transpose(0, 1))
class ResBlock(nn.Module):
def __init__(self, in_channel, channel):
super().__init__()
self.conv = nn.Sequential(
nn.ReLU(inplace=True),
nn.Conv3d(in_channel, channel, 3, padding=1),
nn.ReLU(inplace=True),
nn.Conv3d(channel, in_channel, 1),
)
def forward(self, input):
out = self.conv(input)
out += input
return out
class Encoder(nn.Module):
def __init__(self, in_channel, channel, n_res_block, n_res_channel, stride):
super().__init__()
if stride == 4:
blocks = [
nn.Conv3d(in_channel, channel // 2, 4, stride=2, padding=1),
nn.ReLU(inplace=True),
nn.Conv3d(channel // 2, channel, 4, stride=2, padding=1),
nn.ReLU(inplace=True),
nn.Conv3d(channel, channel, 3, padding=1),
]
elif stride == 2:
blocks = [
nn.Conv3d(in_channel, channel // 2, 4, stride=2, padding=1),
nn.ReLU(inplace=True),
nn.Conv3d(channel // 2, channel, 3, padding=1),
]
for i in range(n_res_block):
blocks.append(ResBlock(channel, n_res_channel))
blocks.append(nn.ReLU(inplace=True))
self.blocks = nn.Sequential(*blocks)
def forward(self, input):
return self.blocks(input)
class Decoder(nn.Module):
def __init__(
self, in_channel, out_channel, channel, n_res_block, n_res_channel, stride
):
super().__init__()
blocks = [nn.Conv3d(in_channel, channel, 3, padding=1)]
for i in range(n_res_block):
blocks.append(ResBlock(channel, n_res_channel))
blocks.append(nn.ReLU(inplace=True))
if stride == 4:
blocks.extend(
[
nn.ConvTranspose3d(channel, channel // 2, 4, stride=2, padding=1),
nn.ReLU(inplace=True),
nn.ConvTranspose3d(
channel // 2, out_channel, 4, stride=2, padding=1
),
]
)
elif stride == 2:
blocks.append(
nn.ConvTranspose3d(channel, out_channel, 4, stride=2, padding=1)
)
self.blocks = nn.Sequential(*blocks)
def forward(self, input):
return self.blocks(input)
class VQVAE(nn.Module):
def __init__(
self,
in_channel=3,
channel=128,
n_res_block=2,
n_res_channel=32,
embed_dim=64,
n_embed=512,
decay=0.99,
):
super().__init__()
self.enc_b = Encoder(in_channel, channel, n_res_block, n_res_channel, stride=4)
self.enc_t = Encoder(channel, channel, n_res_block, n_res_channel, stride=2)
self.quantize_conv_t = nn.Conv3d(channel, embed_dim, 1)
self.quantize_t = Quantize(embed_dim, n_embed)
self.dec_t = Decoder(
embed_dim, embed_dim, channel, n_res_block, n_res_channel, stride=2
)
self.quantize_conv_b = nn.Conv3d(embed_dim + channel, embed_dim, 1)
self.quantize_b = Quantize(embed_dim, n_embed)
self.upsample_t = nn.ConvTranspose3d(
embed_dim, embed_dim, 4, stride=2, padding=1
)
self.dec = Decoder(
embed_dim + embed_dim,
in_channel,
channel,
n_res_block,
n_res_channel,
stride=4,
)
def forward(self, input):
quant_t, quant_b, diff, _, _ = self.encode(input)
dec = self.decode(quant_t, quant_b)
return dec, diff
def encode(self, input):
enc_b = self.enc_b(input)
enc_t = self.enc_t(enc_b)
quant_t = self.quantize_conv_t(enc_t).permute(0, 2, 3, 4, 1)
quant_t, diff_t, id_t = self.quantize_t(quant_t)
quant_t = quant_t.permute(0, 3, 1, 2)
diff_t = diff_t.unsqueeze(0)
dec_t = self.dec_t(quant_t)
enc_b = torch.cat([dec_t, enc_b], 1)
quant_b = self.quantize_conv_b(enc_b).permute(0, 2, 3, 4, 1)
quant_b, diff_b, id_b = self.quantize_b(quant_b)
quant_b = quant_b.permute(0, 4, 1, 2, 3)
diff_b = diff_b.unsqueeze(0)
return quant_t, quant_b, diff_t + diff_b, id_t, id_b
def decode(self, quant_t, quant_b):
upsample_t = self.upsample_t(quant_t)
quant = torch.cat([upsample_t, quant_b], 1)
dec = self.dec(quant)
return dec
def decode_code(self, code_t, code_b):
quant_t = self.quantize_t.embed_code(code_t)
quant_t = quant_t.permute(0, 4, 1, 2, 3)
quant_b = self.quantize_b.embed_code(code_b)
quant_b = quant_b.permute(0, 4, 1, 2, 3)
dec = self.decode(quant_t, quant_b)
return dec
| 7,487 | 31.137339 | 87 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/models/pytorch/autoencoder/variational.py | from functools import partial
import numpy as np
import torch.nn as nn
import torch
from unet3d.models.pytorch.classification.decoder import MyronenkoDecoder, MirroredDecoder
from unet3d.models.pytorch.classification.myronenko import MyronenkoEncoder, MyronenkoConvolutionBlock
from unet3d.models.pytorch.classification.resnet import conv1x1x1
class VariationalBlock(nn.Module):
def __init__(self, in_size, n_features, out_size, return_parameters=False):
super(VariationalBlock, self).__init__()
self.n_features = n_features
self.return_parameters = return_parameters
self.dense1 = nn.Linear(in_size, out_features=n_features*2)
self.dense2 = nn.Linear(self.n_features, out_size)
@staticmethod
def reparameterize(mu, logvar):
std = torch.exp(0.5 * logvar)
eps = torch.randn_like(std)
return mu + eps * std
def forward(self, x):
x = self.dense1(x)
mu, logvar = torch.split(x, self.n_features, dim=1)
z = self.reparameterize(mu, logvar)
out = self.dense2(z)
if self.return_parameters:
return out, mu, logvar, z
else:
return out, mu, logvar
class ConvolutionalAutoEncoder(nn.Module):
def __init__(self, input_shape=None, n_features=1, base_width=32, encoder_blocks=None, decoder_blocks=None,
feature_dilation=2, downsampling_stride=2, interpolation_mode="trilinear",
encoder_class=MyronenkoEncoder, decoder_class=None, n_outputs=None, layer_widths=None,
decoder_mirrors_encoder=False, activation=None, use_transposed_convolutions=False, kernel_size=3):
super(ConvolutionalAutoEncoder, self).__init__()
self.base_width = base_width
if encoder_blocks is None:
encoder_blocks = [1, 2, 2, 4]
self.encoder = encoder_class(n_features=n_features, base_width=base_width, layer_blocks=encoder_blocks,
feature_dilation=feature_dilation, downsampling_stride=downsampling_stride,
layer_widths=layer_widths, kernel_size=kernel_size)
decoder_class, decoder_blocks = self.set_decoder_blocks(decoder_class, encoder_blocks, decoder_mirrors_encoder,
decoder_blocks)
self.decoder = decoder_class(base_width=base_width, layer_blocks=decoder_blocks,
upsampling_scale=downsampling_stride, feature_reduction_scale=feature_dilation,
upsampling_mode=interpolation_mode, layer_widths=layer_widths,
use_transposed_convolutions=use_transposed_convolutions,
kernel_size=kernel_size)
self.set_final_convolution(n_features)
self.set_activation(activation=activation)
def set_final_convolution(self, n_outputs):
self.final_convolution = conv1x1x1(in_planes=self.base_width, out_planes=n_outputs, stride=1)
def set_activation(self, activation):
if activation == "sigmoid":
self.activation = nn.Sigmoid()
elif activation == "softmax":
self.activation = nn.Softmax(dim=1)
else:
self.activation = None
def set_decoder_blocks(self, decoder_class, encoder_blocks, decoder_mirrors_encoder, decoder_blocks):
if decoder_mirrors_encoder:
decoder_blocks = encoder_blocks
if decoder_class is None:
decoder_class = MirroredDecoder
elif decoder_blocks is None:
decoder_blocks = [1] * len(encoder_blocks)
if decoder_class is None:
decoder_class = MyronenkoDecoder
return decoder_class, decoder_blocks
def forward(self, x):
x = self.encoder(x)
x = self.decoder(x)
x = self.final_convolution(x)
if self.activation is not None:
x = self.activation(x)
return x
class MyronenkoVariationalLayer(nn.Module):
def __init__(self, in_features, input_shape, reduced_features=16, latent_features=128,
conv_block=MyronenkoConvolutionBlock, conv_stride=2, upsampling_mode="trilinear",
align_corners_upsampling=False):
super(MyronenkoVariationalLayer, self).__init__()
self.in_conv = conv_block(in_planes=in_features, planes=reduced_features, stride=conv_stride)
self.reduced_shape = tuple(np.asarray((reduced_features, *np.divide(input_shape, conv_stride)), dtype=np.int))
self.in_size = np.prod(self.reduced_shape, dtype=np.int)
self.var_block = VariationalBlock(in_size=self.in_size, out_size=self.in_size, n_features=latent_features)
self.relu = nn.ReLU(inplace=True)
self.out_conv = conv1x1x1(in_planes=reduced_features, out_planes=in_features, stride=1)
self.upsample = partial(nn.functional.interpolate, scale_factor=conv_stride, mode=upsampling_mode,
align_corners=align_corners_upsampling)
def forward(self, x):
x = self.in_conv(x).flatten(start_dim=1)
x, mu, logvar = self.var_block(x)
x = self.relu(x).view(-1, *self.reduced_shape)
x = self.out_conv(x)
x = self.upsample(x)
return x, mu, logvar
class VariationalAutoEncoder(ConvolutionalAutoEncoder):
def __init__(self, n_reduced_latent_feature_maps=16, vae_features=128, variational_layer=MyronenkoVariationalLayer,
input_shape=None, n_features=1, base_width=32, encoder_blocks=None, decoder_blocks=None,
feature_dilation=2, downsampling_stride=2, interpolation_mode="trilinear", encoder_class=MyronenkoEncoder,
decoder_class=MyronenkoDecoder, n_outputs=None, layer_widths=None, decoder_mirrors_encoder=False,
activation=None, use_transposed_convolutions=False, var_layer_stride=2):
super(VariationalAutoEncoder, self).__init__(input_shape=input_shape, n_features=n_features,
base_width=base_width, encoder_blocks=encoder_blocks,
decoder_blocks=decoder_blocks, feature_dilation=feature_dilation,
downsampling_stride=downsampling_stride,
interpolation_mode=interpolation_mode, encoder_class=encoder_class,
decoder_class=decoder_class, n_outputs=n_outputs, layer_widths=layer_widths,
decoder_mirrors_encoder=decoder_mirrors_encoder,
activation=activation,
use_transposed_convolutions=use_transposed_convolutions)
if vae_features is not None:
depth = len(encoder_blocks) - 1
n_latent_feature_maps = base_width * (feature_dilation ** depth)
latent_image_shape = np.divide(input_shape, downsampling_stride ** depth)
self.var_layer = variational_layer(in_features=n_latent_feature_maps,
input_shape=latent_image_shape,
reduced_features=n_reduced_latent_feature_maps,
latent_features=vae_features,
upsampling_mode=interpolation_mode,
conv_stride=var_layer_stride)
def forward(self, x):
x = self.encoder(x)
x, mu, logvar = self.var_layer(x)
x = self.decoder(x)
x = self.final_convolution(x)
if self.activation is not None:
x = self.activation(x)
return x, mu, logvar
def test(self, x):
x = self.encoder(x)
x, mu, logvar = self.var_layer(x)
x = self.decoder(mu)
x = self.final_convolution(x)
if self.activation is not None:
x = self.activation(x)
return x, mu, logvar
class LabeledVariationalAutoEncoder(VariationalAutoEncoder):
def __init__(self, *args, n_outputs=None, base_width=32, **kwargs):
super().__init__(*args, n_outputs=n_outputs, base_width=base_width, **kwargs)
self.final_convolution = conv1x1x1(in_planes=base_width, out_planes=n_outputs, stride=1)
| 8,509 | 51.530864 | 129 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/models/pytorch/graph/graph_cmr_layers.py | """
This file contains definitions of layers used to build the GraphCNN
"""
from __future__ import division
import torch
import torch.nn as nn
import torch.nn.functional as F
import math
class GraphConvolution(nn.Module):
"""Simple GCN layer, similar to https://arxiv.org/abs/1609.02907."""
def __init__(self, in_features, out_features, adjacency_matrix_wrapper, bias=True):
super(GraphConvolution, self).__init__()
self.in_features = in_features
self.out_features = out_features
self.adjacency_matrix_wrapper = adjacency_matrix_wrapper
self.weight = nn.Parameter(torch.FloatTensor(in_features, out_features))
if bias:
self.bias = nn.Parameter(torch.FloatTensor(out_features))
else:
self.register_parameter('bias', None)
self.reset_parameters()
def reset_parameters(self):
# stdv = 1. / math.sqrt(self.weight.size(1))
stdv = 6. / math.sqrt(self.weight.size(0) + self.weight.size(1))
self.weight.data.uniform_(-stdv, stdv)
if self.bias is not None:
self.bias.data.uniform_(-stdv, stdv)
def forward(self, x):
if x.ndimension() == 2:
support = torch.matmul(x, self.weight)
output = torch.matmul(self.adjacency_matrix_wrapper.adjacency_matrix, support)
if self.bias is not None:
output = output + self.bias
return output
else:
output = []
for i in range(x.shape[0]):
support = torch.matmul(x[i], self.weight)
# output.append(torch.matmul(self.adjacency_matrix, support))
output.append(spmm(self.adjacency_matrix_wrapper.adjacency_matrix, support))
output = torch.stack(output, dim=0)
if self.bias is not None:
output = output + self.bias
return output
def __repr__(self):
return self.__class__.__name__ + ' (' \
+ str(self.in_features) + ' -> ' \
+ str(self.out_features) + ')'
class GraphLinear(nn.Module):
"""
Generalization of 1x1 convolutions on Graphs
"""
def __init__(self, in_channels, out_channels):
super(GraphLinear, self).__init__()
self.in_channels = in_channels
self.out_channels = out_channels
self.W = nn.Parameter(torch.FloatTensor(out_channels, in_channels))
self.b = nn.Parameter(torch.FloatTensor(out_channels))
self.reset_parameters()
def reset_parameters(self):
w_stdv = 1 / (self.in_channels * self.out_channels)
self.W.data.uniform_(-w_stdv, w_stdv)
self.b.data.uniform_(-w_stdv, w_stdv)
def forward(self, x):
return torch.matmul(self.W[None, :], x) + self.b[None, :, None]
class GraphResBlock(nn.Module):
"""
Graph Residual Block similar to the Bottleneck Residual Block in ResNet
"""
def __init__(self, in_channels, out_channels, adjacency_matrix_wrapper):
super(GraphResBlock, self).__init__()
self.in_channels = in_channels
self.out_channels = out_channels
self.lin1 = GraphLinear(in_channels, out_channels // 2)
self.conv = GraphConvolution(out_channels // 2, out_channels // 2, adjacency_matrix_wrapper)
self.lin2 = GraphLinear(out_channels // 2, out_channels)
self.skip_conv = GraphLinear(in_channels, out_channels)
self.pre_norm = nn.GroupNorm(in_channels // 8, in_channels)
self.norm1 = nn.GroupNorm((out_channels // 2) // 8, (out_channels // 2))
self.norm2 = nn.GroupNorm((out_channels // 2) // 8, (out_channels // 2))
def forward(self, x):
y = F.relu(self.pre_norm(x))
y = self.lin1(y)
y = F.relu(self.norm1(y))
y = self.conv(y.transpose(1, 2)).transpose(1, 2)
y = F.relu(self.norm2(y))
y = self.lin2(y)
if self.in_channels != self.out_channels:
x = self.skip_conv(x)
return x+y
class SparseMM(torch.autograd.Function):
"""Redefine sparse @ dense matrix multiplication to enable backpropagation.
The builtin matrix multiplication operation does not support backpropagation in some cases.
"""
@staticmethod
def forward(ctx, sparse, dense):
ctx.req_grad = dense.requires_grad
ctx.save_for_backward(sparse)
return torch.matmul(sparse, dense)
@staticmethod
def backward(ctx, grad_output):
grad_input = None
sparse, = ctx.saved_tensors
if ctx.req_grad:
grad_input = torch.matmul(sparse.t(), grad_output)
return None, grad_input
def spmm(sparse, dense):
return SparseMM.apply(sparse, dense)
| 4,710 | 35.238462 | 100 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/models/pytorch/graph/utils.py | from itertools import permutations
import nibabel as nib
import torch
import os
def load_surface(surface_filename):
surface = nib.load(os.path.abspath(surface_filename))
vertices = surface.darrays[0].data
n_vertices = vertices.shape[0]
faces = surface.darrays[1].data
adjacency_matrix = faces_to_adjacency_matrix(faces, size=(n_vertices, n_vertices))
return torch.FloatTensor(vertices).t(), adjacency_matrix
def faces_to_edges(faces):
edges = list()
for face in faces:
edges.extend(list(permutations(face, 2)))
return torch.LongTensor(edges).t()
def faces_to_adjacency_matrix(faces, size):
indices = faces_to_edges(faces)
values = torch.zeros(indices.shape[1], dtype=torch.float)
adjacency_matrix = torch.sparse.FloatTensor(indices, values, size=size)
return adjacency_matrix
class AdjacencyMatrixWrapper(object):
def __init__(self, adjacency_matrix):
self.adjacency_matrix = adjacency_matrix
| 973 | 28.515152 | 86 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/models/pytorch/graph/graph_cmr_net.py | """
Modified from:
https://github.com/nkolot/GraphCMR/blob/master/models/graph_cnn.py
"""
from __future__ import division
import torch
import torch.nn as nn
from .graph_cmr_layers import GraphResBlock, GraphLinear
from .utils import load_surface, AdjacencyMatrixWrapper
from ..classification.resnet import resnet_18
class GraphCMR(nn.Module):
def __init__(self, n_outputs=None, ref_vertices=None, adjacency_matrix=None, n_layers=5, n_channels=256,
output_features=3, encoder=resnet_18, encoder_outputs=512, reference_filename=None, **encoder_kwargs):
super(GraphCMR, self).__init__()
if reference_filename is not None and (ref_vertices is None or adjacency_matrix is None):
ref_vertices, adjacency_matrix = load_surface(surface_filename=reference_filename)
self.adjacency_matrix_wrapper = AdjacencyMatrixWrapper(adjacency_matrix)
self.ref_vertices = ref_vertices
self.encoder = encoder(n_outputs=encoder_outputs, **encoder_kwargs)
self.encoder_outputs = encoder_outputs
layers = [GraphLinear(3 + self.encoder_outputs, 2 * n_channels),
GraphResBlock(2 * n_channels, n_channels, self.adjacency_matrix_wrapper)]
for i in range(n_layers):
layers.append(GraphResBlock(n_channels, n_channels, self.adjacency_matrix_wrapper))
self.shape = nn.Sequential(GraphResBlock(n_channels, 64, self.adjacency_matrix_wrapper),
GraphResBlock(64, 32, self.adjacency_matrix_wrapper),
nn.GroupNorm(32 // 8, 32),
nn.ReLU(inplace=True),
GraphLinear(32, output_features))
self.gc = nn.Sequential(*layers)
def forward(self, x):
"""Forward pass
Inputs:
x: size = (B, 3, 224, 224)
Returns:
Regressed (subsampled) non-parametric shape: size = (B, 1723, 3)
Weak-perspective camera: size = (B, 3)
"""
batch_size = x.shape[0]
ref_vertices = self.ref_vertices[None, :, :].expand(batch_size, -1, -1)
x = self.encoder(x)
x = x.view(batch_size, self.encoder_outputs, 1).expand(-1, -1, ref_vertices.shape[-1])
x = torch.cat([ref_vertices, x], dim=1)
x = self.gc(x)
shape = self.shape(x)
return shape
def cuda(self, *args, **kwargs):
self.ref_vertices = self.ref_vertices.cuda(*args, **kwargs)
self.adjacency_matrix_wrapper.adjacency_matrix = self.adjacency_matrix_wrapper.adjacency_matrix.cuda(*args,
**kwargs)
return super(GraphCMR, self).cuda(*args, **kwargs)
| 2,788 | 45.483333 | 119 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/scripts/train.py | import os
import argparse
import pandas as pd
import numpy as np
from unet3d.train import run_training
from unet3d.utils.filenames import wrapped_partial, generate_filenames, load_bias, load_sequence
from unet3d.utils.sequences import (WholeVolumeToSurfaceSequence, HCPRegressionSequence, ParcelBasedSequence,
WindowedAutoEncoderSequence)
from unet3d.utils.pytorch.dataset import (WholeBrainCIFTI2DenseScalarDataset, HCPRegressionDataset, AEDataset,
WholeVolumeSegmentationDataset, WindowedAEDataset)
from unet3d.utils.utils import load_json, in_config, dump_json
from unet3d.utils.custom import get_metric_data_from_config
from unet3d.scripts.predict import format_parser as format_prediction_args
from unet3d.scripts.predict import run_inference
from unet3d.scripts.script_utils import get_machine_config, add_machine_config_to_parser
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument("--config_filename", required=True,
help="JSON configuration file specifying the parameters for model training.")
parser.add_argument("--model_filename",
help="Location to save the model during and after training. If this filename exists "
"prior to training, the model will be loaded from the filename.",
required=True)
parser.add_argument("--training_log_filename",
help="CSV filename to save the to save the training and validation results for each epoch.",
required=True)
parser.add_argument("--fit_gpu_mem", type=float,
help="Specify the amount of gpu memory available on a single gpu and change the image size to "
"fit into gpu memory automatically. Will try to find the largest image size that will fit "
"onto a single gpu. The batch size is overwritten and set to the number of gpus available."
" The new image size will be written to a new config file ending named "
"'<original_config>_auto.json'. This option is experimental and only works with the UNet "
"model. It has only been tested with gpus that have 12GB and 32GB of memory.")
parser.add_argument("--group_average_filenames")
parser.add_argument("--batch_size", help="Override the batch size from the config file.", type=int)
parser.add_argument("--debug", action="store_true", default=False,
help="Raises an error if a training file is not found. The default is to silently skip"
"any training files that cannot be found. Use this flag to debug the config for finding"
"the data.")
add_machine_config_to_parser(parser)
subparsers = parser.add_subparsers(help="sub-commands", dest='sub_command')
prediction_parser = subparsers.add_parser(name="predict",
help="Run prediction after the model has finished training")
format_prediction_args(prediction_parser, sub_command=True)
args = parser.parse_args()
return args
def check_hierarchy(config):
if in_config("labels", config["sequence_kwargs"]) and in_config("use_label_hierarchy", config["sequence_kwargs"]):
config["sequence_kwargs"].pop("use_label_hierarchy")
labels = config["sequence_kwargs"].pop("labels")
new_labels = list()
while len(labels):
new_labels.append(labels)
labels = labels[1:]
config["sequence_kwargs"]["labels"] = new_labels
def compute_unet_number_of_voxels(window, channels, n_layers):
n_voxels = 0
for i in range(n_layers):
n_voxels = n_voxels + ((1/(2**(3*i))) * window[0] * window[1] * window[2] * channels * 2**i * 2)
return n_voxels
def compute_window_size(step, step_size, ratios):
step_ratios = np.asarray(ratios) * step * step_size
mod = np.mod(step_ratios, step_size)
return np.asarray(step_ratios - mod + np.round(mod / step_size) * step_size, dtype=int)
def update_config_to_fit_gpu_memory(config, n_gpus, gpu_memory, output_filename, voxels_per_gb=17000000.0,
ratios=(1.22, 1.56, 1.0)):
max_voxels = voxels_per_gb * gpu_memory
n_layers = len(config["model_kwargs"]["encoder_blocks"])
step_size = 2**(n_layers - 1)
step = 1
window = compute_window_size(step, step_size, ratios)
n_voxels = compute_unet_number_of_voxels(window, config["model_kwargs"]["base_width"], n_layers)
while n_voxels <= max_voxels:
step = step + 1
window = compute_window_size(step, step_size, ratios)
n_voxels = compute_unet_number_of_voxels(window, config["model_kwargs"]["base_width"], n_layers)
window = compute_window_size(step - 1, step_size, ratios).tolist()
print("Setting window size to {} x {} x {}".format(*window))
print("Setting batch size to", n_gpus)
config["window"] = window
config["model_kwargs"]["input_shape"] = window
config["batch_size"] = n_gpus
config["validation_batch_size"] = n_gpus
print("Writing new configuration file:", output_filename)
dump_json(config, output_filename)
def main():
import nibabel as nib
nib.imageglobals.logger.level = 40
namespace = parse_args()
print("Config: ", namespace.config_filename)
config = load_json(namespace.config_filename)
if "package" in config:
package = config["package"]
else:
package = "keras"
if "metric_names" in config and not config["n_outputs"] == len(config["metric_names"]):
raise ValueError("n_outputs set to {}, but number of metrics is {}.".format(config["n_outputs"],
len(config["metric_names"])))
print("Model: ", namespace.model_filename)
print("Log: ", namespace.training_log_filename)
system_config = get_machine_config(namespace)
training_function_kwargs = in_config("training_function_kwargs", config, dict())
# set verbosity
if namespace.debug:
if "sequence_kwargs" not in config:
config["sequence_kwargs"] = dict()
config["sequence_kwargs"]["verbose"] = namespace.debug
# Override the batch size from the config file
if namespace.batch_size:
config["batch_size"] = namespace.batch_size
if namespace.fit_gpu_mem and namespace.fit_gpu_mem > 0:
update_config_to_fit_gpu_memory(config=config, n_gpus=system_config["n_gpus"], gpu_memory=namespace.fit_gpu_mem,
output_filename=namespace.config_filename.replace(".json", "_auto.json"))
if namespace.group_average_filenames is not None:
group_average = get_metric_data_from_config(namespace.group_average_filenames, namespace.config_filename)
from unet3d.models.keras.resnet.resnet import compare_scores
model_metrics = [wrapped_partial(compare_scores, comparison=group_average)]
metric_to_monitor = "compare_scores"
else:
model_metrics = []
if config['skip_validation']:
metric_to_monitor = "loss"
else:
metric_to_monitor = "val_loss"
if config["skip_validation"]:
groups = ("training",)
else:
groups = ("training", "validation")
if "directory" in system_config:
directory = system_config.pop("directory")
elif "directory" in config:
directory = config["directory"]
else:
directory = ""
for name in groups:
key = name + "_filenames"
if key not in config:
config[key] = generate_filenames(config, name, directory,
raise_if_not_exists=namespace.debug)
if "sequence" in config:
sequence_class = load_sequence(config["sequence"])
elif "_wb_" in os.path.basename(namespace.config_filename):
if "package" in config and config["package"] == "pytorch":
if config["sequence"] == "AEDataset":
sequence_class = AEDataset
elif config["sequence"] == "WholeVolumeSegmentationDataset":
sequence_class = WholeVolumeSegmentationDataset
else:
sequence_class = WholeBrainCIFTI2DenseScalarDataset
else:
sequence_class = WholeVolumeToSurfaceSequence
elif config["sequence"] == "WindowedAutoEncoderSequence":
sequence_class = WindowedAutoEncoderSequence
elif config["sequence"] == "WindowedAEDataset":
sequence_class = WindowedAEDataset
elif "_pb_" in os.path.basename(namespace.config_filename):
sequence_class = ParcelBasedSequence
config["sequence_kwargs"]["parcellation_template"] = os.path.join(
directory, config["sequence_kwargs"]["parcellation_template"])
else:
if config["package"] == "pytorch":
sequence_class = HCPRegressionDataset
else:
sequence_class = HCPRegressionSequence
if "bias_filename" in config and config["bias_filename"] is not None:
bias = load_bias(config["bias_filename"])
else:
bias = None
check_hierarchy(config)
if in_config("add_contours", config["sequence_kwargs"], False):
config["n_outputs"] = config["n_outputs"] * 2
if sequence_class == ParcelBasedSequence:
target_parcels = config["sequence_kwargs"].pop("target_parcels")
for target_parcel in target_parcels:
config["sequence_kwargs"]["target_parcel"] = target_parcel
print("Training on parcel: {}".format(target_parcel))
if type(target_parcel) == list:
parcel_id = "-".join([str(i) for i in target_parcel])
else:
parcel_id = str(target_parcel)
_training_log_filename = namespace.training_log_filename.replace(".csv", "_{}.csv".format(parcel_id))
if os.path.exists(_training_log_filename):
_training_log = pd.read_csv(_training_log_filename)
if (_training_log[metric_to_monitor].values.argmin()
<= len(_training_log) - int(config["early_stopping_patience"])):
print("Already trained")
continue
run_training(package,
config,
namespace.model_filename.replace(".h5", "_{}.h5".format(parcel_id)),
_training_log_filename,
sequence_class=sequence_class,
model_metrics=model_metrics,
metric_to_monitor=metric_to_monitor,
**training_function_kwargs,
**system_config)
else:
run_training(package, config, namespace.model_filename, namespace.training_log_filename,
sequence_class=sequence_class,
model_metrics=model_metrics,
metric_to_monitor=metric_to_monitor,
bias=bias,
**training_function_kwargs,
**system_config)
if namespace.sub_command == "predict":
run_inference(namespace)
if __name__ == '__main__':
main()
| 11,414 | 46.169421 | 120 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/train/keras.py | import os
from keras.callbacks import ModelCheckpoint, ReduceLROnPlateau, CSVLogger
import keras
import nibabel as nib
from unet3d.models.keras.load import load_model
from unet3d.models.keras.build import build_model
import numpy as np
from unet3d.utils.sequences import HCPRegressionSequence
def run_keras_training(config, model_filename, training_log_filename, verbose=1, use_multiprocessing=False,
n_workers=1, max_queue_size=5, model_name='resnet_34', sequence_class=HCPRegressionSequence,
test_input=1, metric_to_monitor="loss", model_metrics=(), n_gpus=1):
"""
:param test_input: integer with the number of inputs from the generator to write to file. 0, False, or None will
write no inputs to file.
:param sequence_class: class to use for the generator sequence
:param model_name:
:param verbose:
:param use_multiprocessing:
:param n_workers:
:param max_queue_size:
:param config:
:param model_filename:
:param training_log_filename:
:param metric_to_monitor:
:param model_metrics:
:return:
Anything that directly affects the training results should go into the config file. Other specifications such as
multiprocessing optimization should be arguments to this function, as these arguments affect the computation time,
but the results should not vary based on whether multiprocessing is used or not.
"""
window = np.asarray(config['window'])
spacing = np.asarray(config['spacing'])
if 'model_name' in config:
model_name = config['model_name']
# 2. Create model_filename
if os.path.exists(model_filename):
model = load_model(model_filename)
else:
input_shape = tuple(window.tolist() + [config['n_features']])
if "n_outputs" in config:
num_outputs = config['n_outputs']
else:
num_outputs = len(np.concatenate(config['metric_names']))
model = build_model(model_name, input_shape=input_shape, num_outputs=num_outputs,
activation=config['activation'])
if "freeze_bias" in config and config["freeze_bias"]:
dense = model.layers[-1]
bias = dense.trainable_weights.pop(dense.trainable_weights.index(dense.bias))
dense.non_trainable_weights.append(bias)
model.optimizer = None
if n_gpus > 1:
from keras.utils import multi_gpu_model
model = multi_gpu_model(model, n_gpus)
model.optimizer = None
if not hasattr(model, 'optimizer') or model.optimizer is None:
model.compile(optimizer=config['optimizer'], loss=config['loss'], metrics=model_metrics)
if "initial_learning_rate" in config:
keras.backend.set_value(model.optimizer.lr, config['initial_learning_rate'])
if "iterations_per_epoch" in config:
iterations_per_epoch = config["iterations_per_epoch"]
else:
iterations_per_epoch = 1
if "additional_training_args" in config:
train_kwargs = config["additional_training_args"]
else:
train_kwargs = dict()
if "sequence_kwargs" in config:
sequence_kwargs = config["sequence_kwargs"]
else:
sequence_kwargs = dict()
# 4. Create Generators
training_generator = sequence_class(filenames=config['training_filenames'],
batch_size=config['batch_size'],
flip=config['flip'],
reorder=config['reorder'],
window=window,
spacing=spacing,
points_per_subject=config['points_per_subject'],
surface_names=config['surface_names'],
metric_names=config['metric_names'],
iterations_per_epoch=iterations_per_epoch,
**train_kwargs,
**sequence_kwargs)
if test_input:
n_test_batches = int(np.ceil(test_input/float(config['batch_size'])))
for batch_index in range(n_test_batches):
x, y = training_generator[batch_index]
for within_batch_index in range(min([config['batch_size'],
test_input - (batch_index * config['batch_size'])])):
x_image = nib.Nifti1Image(x[within_batch_index], affine=np.diag(np.ones(4)))
x_image.to_filename(model_filename.replace(".h5",
"_input_test_{}.nii.gz".format(
within_batch_index
+ config['batch_size']
* batch_index)))
if 'skip_validation' in config and config['skip_validation']:
validation_generator = None
else:
validation_generator = sequence_class(filenames=config['validation_filenames'],
batch_size=config['validation_batch_size'],
flip=False,
reorder=config['reorder'],
window=window,
spacing=spacing,
points_per_subject=config['validation_points_per_subject'],
surface_names=config['surface_names'],
metric_names=config['metric_names'],
**sequence_kwargs)
# 5. Run Training
callbacks = []
checkpointer = ModelCheckpoint(filepath=model_filename,
verbose=verbose,
monitor=metric_to_monitor,
mode="min",
save_best_only=config['save_best_only'])
callbacks.append(checkpointer)
if config["decay_patience"]:
reduce_lr = ReduceLROnPlateau(monitor=metric_to_monitor,
factor=config['decay_factor'],
patience=config['decay_patience'],
min_lr=config['min_learning_rate'])
print("Will reduce LR by a factor of {} after {} epochs.".format(config["decay_factor"],
config["decay_patience"]))
callbacks.append(reduce_lr)
csv_logger = CSVLogger(training_log_filename, append=True)
callbacks.append(csv_logger)
if "early_stopping_patience" in config and config["early_stopping_patience"]:
from keras.callbacks import EarlyStopping
print("Will stop training after {} epochs without {} decrease.".format(config["early_stopping_patience"],
metric_to_monitor))
early_stopping = EarlyStopping(monitor=metric_to_monitor,
patience=config["early_stopping_patience"],
verbose=verbose)
callbacks.append(early_stopping)
history = model.fit_generator(generator=training_generator,
epochs=config['n_epochs'],
use_multiprocessing=use_multiprocessing,
workers=n_workers,
max_queue_size=max_queue_size,
callbacks=callbacks,
validation_data=validation_generator)
| 7,893 | 49.929032 | 118 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/train/pytorch.py | import os
import shutil
import warnings
import numpy as np
import nibabel as nib
import pandas as pd
import torch
from torch.utils.data import DataLoader
import torch.nn
from ..models.pytorch.build import build_or_load_model
from ..utils.pytorch import WholeBrainCIFTI2DenseScalarDataset
from .pytorch_training_utils import epoch_training, epoch_validatation, collate_flatten, collate_5d_flatten
from ..utils.pytorch import functions
from ..utils.utils import in_config
def build_optimizer(optimizer_name, model_parameters, learning_rate=1e-4):
return getattr(torch.optim, optimizer_name)(model_parameters, lr=learning_rate)
def run_pytorch_training(config, model_filename, training_log_filename, verbose=1, use_multiprocessing=False,
n_workers=1, max_queue_size=5, model_name='resnet_34', n_gpus=1, regularized=False,
sequence_class=WholeBrainCIFTI2DenseScalarDataset, directory=None, test_input=1,
metric_to_monitor="loss", model_metrics=(), bias=None, pin_memory=False, amp=False,
prefetch_factor=1, **unused_args):
"""
:param test_input: integer with the number of inputs from the generator to write to file. 0, False, or None will
write no inputs to file.
:param sequence_class: class to use for the generator sequence
:param model_name:
:param verbose:
:param use_multiprocessing:
:param n_workers:
:param max_queue_size:
:param config:
:param model_filename:
:param training_log_filename:
:param metric_to_monitor:
:param model_metrics:
:return:
Anything that directly affects the training results should go into the config file. Other specifications such as
multiprocessing optimization should be arguments to this function, as these arguments affect the computation time,
but the results should not vary based on whether multiprocessing is used or not.
"""
window = np.asarray(config['window'])
spacing = np.asarray(config['spacing']) if 'spacing' in config else None
if 'model_name' in config:
model_name = config['model_name']
if "n_outputs" in config:
n_outputs = config['n_outputs']
else:
n_outputs = len(np.concatenate(config['metric_names']))
if "model_kwargs" in config:
model_kwargs = config["model_kwargs"]
if "input_shape" not in config["model_kwargs"]:
# assume that the model will take in the whole image window
config["model_kwargs"]["input_shape"] = window
else:
model_kwargs = dict()
model = build_or_load_model(model_name, model_filename, n_features=config["n_features"], n_outputs=n_outputs,
freeze_bias=in_config("freeze_bias", config, False),
bias=bias, n_gpus=n_gpus, **model_kwargs)
model.train()
criterion = load_criterion(config['loss'], n_gpus=n_gpus)
if "weights" in config and config["weights"] is not None:
criterion = functions.WeightedLoss(torch.tensor(config["weights"]), criterion)
optimizer_kwargs = dict()
if "initial_learning_rate" in config:
optimizer_kwargs["learning_rate"] = config["initial_learning_rate"]
optimizer = build_optimizer(optimizer_name=config["optimizer"],
model_parameters=model.parameters(),
**optimizer_kwargs)
sequence_kwargs = in_config("sequence_kwargs", config, dict())
if "flatten_y" in config and config["flatten_y"]:
collate_fn = collate_flatten
elif "collate_fn" in config and config["collate_fn"] == "collate_5d_flatten":
collate_fn = collate_5d_flatten
else:
from torch.utils.data.dataloader import default_collate
collate_fn = default_collate
# 4. Create datasets
training_dataset = sequence_class(filenames=config['training_filenames'],
flip=in_config('flip', config, False),
reorder=config['reorder'],
window=window,
spacing=spacing,
points_per_subject=in_config('points_per_subject', config, 1),
surface_names=in_config('surface_names', config, None),
metric_names=in_config('metric_names', config, None),
base_directory=directory,
subject_ids=config["training"],
iterations_per_epoch=in_config("iterations_per_epoch", config, 1),
**in_config("additional_training_args", config, dict()),
**sequence_kwargs)
training_loader = DataLoader(training_dataset,
batch_size=config["batch_size"] // in_config('points_per_subject', config, 1),
shuffle=True,
num_workers=n_workers,
collate_fn=collate_fn,
pin_memory=pin_memory,
prefetch_factor=prefetch_factor)
if test_input:
for index in range(test_input):
x, y = training_dataset[index]
if not isinstance(x, np.ndarray):
x = x.numpy()
y = y.numpy()
x = np.moveaxis(x, 0, -1)
x_image = nib.Nifti1Image(x.squeeze(), affine=np.diag(np.ones(4)))
x_image.to_filename(model_filename.replace(".h5",
"_input_test_{}.nii.gz".format(index)))
if len(y.shape) >= 3:
y = np.moveaxis(y, 0, -1)
y_image = nib.Nifti1Image(y.squeeze(), affine=np.diag(np.ones(4)))
y_image.to_filename(model_filename.replace(".h5",
"_target_test_{}.nii.gz".format(index)))
if 'skip_validation' in config and config['skip_validation']:
validation_loader = None
metric_to_monitor = "loss"
else:
validation_dataset = sequence_class(filenames=config['validation_filenames'],
flip=False,
reorder=config['reorder'],
window=window,
spacing=spacing,
points_per_subject=in_config('validation_points_per_subject', config, 1),
surface_names=in_config('surface_names', config, None),
metric_names=in_config('metric_names', config, None),
**sequence_kwargs,
**in_config("additional_validation_args", config, dict()))
validation_loader = DataLoader(validation_dataset,
batch_size=config["validation_batch_size"] // in_config("points_per_subject",
config, 1),
shuffle=False,
num_workers=n_workers,
collate_fn=collate_fn,
pin_memory=pin_memory,
prefetch_factor=prefetch_factor)
train(model=model, optimizer=optimizer, criterion=criterion, n_epochs=config["n_epochs"], verbose=bool(verbose),
training_loader=training_loader, validation_loader=validation_loader, model_filename=model_filename,
training_log_filename=training_log_filename,
metric_to_monitor=metric_to_monitor,
early_stopping_patience=in_config("early_stopping_patience", config),
save_best=in_config("save_best", config, False),
learning_rate_decay_patience=in_config("decay_patience", config),
regularized=in_config("regularized", config, regularized),
n_gpus=n_gpus,
vae=in_config("vae", config, False),
decay_factor=in_config("decay_factor", config),
min_lr=in_config("min_learning_rate", config),
learning_rate_decay_step_size=in_config("decay_step_size", config),
save_every_n_epochs=in_config("save_every_n_epochs", config),
save_last_n_models=in_config("save_last_n_models", config),
amp=amp)
def train(model, optimizer, criterion, n_epochs, training_loader, validation_loader, training_log_filename,
model_filename, metric_to_monitor="val_loss", early_stopping_patience=None,
learning_rate_decay_patience=None, save_best=False, n_gpus=1, verbose=True, regularized=False,
vae=False, decay_factor=0.1, min_lr=0., learning_rate_decay_step_size=None, save_every_n_epochs=None,
save_last_n_models=None, amp=False):
training_log = list()
if os.path.exists(training_log_filename):
training_log.extend(pd.read_csv(training_log_filename).values)
start_epoch = int(training_log[-1][0]) + 1
else:
start_epoch = 0
training_log_header = ["epoch", "loss", "lr", "val_loss"]
if learning_rate_decay_patience:
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, patience=learning_rate_decay_patience,
verbose=verbose, factor=decay_factor, min_lr=min_lr)
elif learning_rate_decay_step_size:
scheduler = torch.optim.lr_scheduler.StepLR(optimizer=optimizer, step_size=learning_rate_decay_step_size,
gamma=decay_factor, last_epoch=-1)
# Setting the last epoch to anything other than -1 requires the optimizer that was previously used.
# Since I don't save the optimizer, I have to manually step the scheduler the number of epochs that have already
# been completed. Stepping the scheduler before the optimizer raises a warning, so I have added the below
# code to step the scheduler and catch the UserWarning that would normally be thrown.
with warnings.catch_warnings():
warnings.simplefilter("ignore")
for i in range(start_epoch):
scheduler.step()
else:
scheduler = None
if amp:
from torch.cuda.amp import GradScaler
scaler = GradScaler()
else:
scaler = None
for epoch in range(start_epoch, n_epochs):
# early stopping
if (training_log and early_stopping_patience
and np.asarray(training_log)[:, training_log_header.index(metric_to_monitor)].argmin()
<= len(training_log) - early_stopping_patience):
print("Early stopping patience {} has been reached.".format(early_stopping_patience))
break
# train the model
loss = epoch_training(training_loader, model, criterion, optimizer=optimizer, epoch=epoch, n_gpus=n_gpus,
regularized=regularized, vae=vae, scaler=scaler)
try:
training_loader.dataset.on_epoch_end()
except AttributeError:
warnings.warn("'on_epoch_end' method not implemented for the {} dataset.".format(
type(training_loader.dataset)))
# Clear the cache from the GPUs
if n_gpus:
torch.cuda.empty_cache()
# predict validation data
if validation_loader:
val_loss = epoch_validatation(validation_loader, model, criterion, n_gpus=n_gpus, regularized=regularized,
vae=vae, use_amp=scaler is not None)
else:
val_loss = None
# update the training log
training_log.append([epoch, loss, get_lr(optimizer), val_loss])
pd.DataFrame(training_log, columns=training_log_header).set_index("epoch").to_csv(training_log_filename)
min_epoch = np.asarray(training_log)[:, training_log_header.index(metric_to_monitor)].argmin()
# check loss and decay
if scheduler:
if validation_loader and scheduler.__class__ == torch.optim.lr_scheduler.ReduceLROnPlateau:
scheduler.step(val_loss)
elif scheduler.__class__ == torch.optim.lr_scheduler.ReduceLROnPlateau:
scheduler.step(loss)
else:
scheduler.step()
# save model
torch.save(model.state_dict(), model_filename)
if save_best and min_epoch == len(training_log) - 1:
best_filename = model_filename.replace(".h5", "_best.h5")
forced_copy(model_filename, best_filename)
if save_every_n_epochs and (epoch % save_every_n_epochs) == 0:
epoch_filename = model_filename.replace(".h5", "_{}.h5".format(epoch))
forced_copy(model_filename, epoch_filename)
if save_last_n_models is not None and save_last_n_models > 1:
if not save_every_n_epochs or not ((epoch - save_last_n_models) % save_every_n_epochs) == 0:
to_delete = model_filename.replace(".h5", "_{}.h5".format(epoch - save_last_n_models))
remove_file(to_delete)
epoch_filename = model_filename.replace(".h5", "_{}.h5".format(epoch))
forced_copy(model_filename, epoch_filename)
def forced_copy(source, target):
remove_file(target)
shutil.copy(source, target)
def remove_file(filename):
if os.path.exists(filename):
os.remove(filename)
def get_lr(optimizer):
lrs = [params['lr'] for params in optimizer.param_groups]
return np.squeeze(np.unique(lrs))
def load_criterion(criterion_name, n_gpus=0):
try:
criterion = getattr(functions, criterion_name)
except AttributeError:
criterion = getattr(torch.nn, criterion_name)()
if n_gpus > 0:
criterion.cuda()
return criterion
| 14,187 | 47.589041 | 120 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/train/pytorch_training_utils.py | """
Modified from: https://github.com/pytorch/examples/blob/master/imagenet/main.py
"""
import shutil
import time
import torch
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
try:
from torch.utils.data._utils.collate import default_collate
except ModuleNotFoundError:
# import from older versions of pytorch
from torch.utils.data.dataloader import default_collate
def epoch_training(train_loader, model, criterion, optimizer, epoch, n_gpus=None, print_frequency=1, regularized=False,
print_gpu_memory=False, vae=False, scaler=None):
batch_time = AverageMeter('Time', ':6.3f')
data_time = AverageMeter('Data', ':6.3f')
losses = AverageMeter('Loss', ':.4e')
progress = ProgressMeter(
len(train_loader),
[batch_time, data_time, losses],
prefix="Epoch: [{}]".format(epoch))
use_amp = scaler is not None
# switch to train mode
model.train()
end = time.time()
for i, (images, target) in enumerate(train_loader):
# measure data loading time
data_time.update(time.time() - end)
if n_gpus:
torch.cuda.empty_cache()
if print_gpu_memory:
for i_gpu in range(n_gpus):
print("Memory allocated (device {}):".format(i_gpu),
human_readable_size(torch.cuda.memory_allocated(i_gpu)))
print("Max memory allocated (device {}):".format(i_gpu),
human_readable_size(torch.cuda.max_memory_allocated(i_gpu)))
print("Memory cached (device {}):".format(i_gpu),
human_readable_size(torch.cuda.memory_cached(i_gpu)))
print("Max memory cached (device {}):".format(i_gpu),
human_readable_size(torch.cuda.max_memory_cached(i_gpu)))
optimizer.zero_grad()
loss, batch_size = batch_loss(model, images, target, criterion, n_gpus=n_gpus, regularized=regularized,
vae=vae, use_amp=use_amp)
if n_gpus:
torch.cuda.empty_cache()
# measure accuracy and record loss
losses.update(loss.item(), batch_size)
if scaler:
scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()
else:
# compute gradient and do step
loss.backward()
optimizer.step()
del loss
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if i % print_frequency == 0:
progress.display(i)
return losses.avg
def batch_loss(model, images, target, criterion, n_gpus=0, regularized=False, vae=False, use_amp=None):
if n_gpus is not None:
torch.cuda.empty_cache()
images = images.cuda()
target = target.cuda()
# compute output
if use_amp:
from torch.cuda.amp import autocast
with autocast():
return _batch_loss(model, images, target, criterion, regularized=regularized, vae=vae)
else:
return _batch_loss(model, images, target, criterion, regularized=regularized, vae=vae)
def _batch_loss(model, images, target, criterion, regularized=False, vae=False):
output = model(images)
batch_size = images.size(0)
if regularized:
try:
output, output_vae, mu, logvar = output
loss = criterion(output, output_vae, mu, logvar, images, target)
except ValueError:
pred_y, pred_x = output
loss = criterion(pred_y, pred_x, images, target)
elif vae:
pred_x, mu, logvar = output
loss = criterion(pred_x, mu, logvar, target)
else:
loss = criterion(output, target)
return loss, batch_size
def epoch_validatation(val_loader, model, criterion, n_gpus, print_freq=1, regularized=False, vae=False, use_amp=False):
batch_time = AverageMeter('Time', ':6.3f')
losses = AverageMeter('Loss', ':.4e')
progress = ProgressMeter(
len(val_loader),
[batch_time, losses],
prefix='Validation: ')
# switch to evaluate mode
model.eval()
with torch.no_grad():
end = time.time()
for i, (images, target) in enumerate(val_loader):
loss, batch_size = batch_loss(model, images, target, criterion, n_gpus=n_gpus, regularized=regularized,
vae=vae, use_amp=use_amp)
# measure accuracy and record loss
losses.update(loss.item(), batch_size)
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if i % print_freq == 0:
progress.display(i)
if n_gpus:
torch.cuda.empty_cache()
return losses.avg
def save_checkpoint(state, is_best, filename='checkpoint.pth.tar'):
torch.save(state, filename)
if is_best:
shutil.copyfile(filename, 'model_best.pth.tar')
class AverageMeter(object):
"""Computes and stores the average and current value"""
def __init__(self, name, fmt=':f'):
self.name = name
self.fmt = fmt
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
self.val = val
self.sum += val * n
self.count += n
self.avg = self.sum / self.count
def __str__(self):
fmtstr = '{name} {val' + self.fmt + '} ({avg' + self.fmt + '})'
return fmtstr.format(**self.__dict__)
class ProgressMeter(object):
def __init__(self, num_batches, meters, prefix=""):
self.batch_fmtstr = self._get_batch_fmtstr(num_batches)
self.meters = meters
self.prefix = prefix
def display(self, batch):
entries = [self.prefix + self.batch_fmtstr.format(batch)]
entries += [str(meter) for meter in self.meters]
print('\t'.join(entries))
def _get_batch_fmtstr(self, num_batches):
num_digits = len(str(num_batches // 1))
fmt = '{:' + str(num_digits) + 'd}'
return '[' + fmt + '/' + fmt.format(num_batches) + ']'
def adjust_learning_rate(optimizer, epoch, args):
"""Sets the learning rate to the initial LR decayed by 10 every 30 epochs"""
lr = args.lr * (0.1 ** (epoch // 30))
for param_group in optimizer.param_groups:
param_group['lr'] = lr
def accuracy(output, target, topk=(1,)):
"""Computes the accuracy over the k top predictions for the specified values of k"""
with torch.no_grad():
maxk = max(topk)
batch_size = target.size(0)
_, pred = output.topk(maxk, 1, True, True)
pred = pred.t()
correct = pred.eq(target.view(1, -1).expand_as(pred))
res = []
for k in topk:
correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)
res.append(correct_k.mul_(100.0 / batch_size))
return res
def human_readable_size(size, decimal_places=1):
for unit in ['', 'KB', 'MB', 'GB', 'TB']:
if size < 1024.0:
break
size /= 1024.0
return f"{size:.{decimal_places}f}{unit}"
def collate_flatten(batch, x_dim_flatten=5, y_dim_flatten=2):
x, y = default_collate(batch)
if len(x.shape) > x_dim_flatten:
x = x.flatten(start_dim=0, end_dim=len(x.shape) - x_dim_flatten)
if len(y.shape) > y_dim_flatten:
y = y.flatten(start_dim=0, end_dim=len(y.shape) - y_dim_flatten)
return [x, y]
def collate_5d_flatten(batch, dim_flatten=5):
return collate_flatten(batch, x_dim_flatten=dim_flatten, y_dim_flatten=dim_flatten)
| 7,760 | 31.472803 | 120 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/train/train.py |
def run_training_with_package(package="keras", *args, **kwargs):
"""
Agnostic function to run the training with the specified deep learning package/framework.
:param package:
:param args:
:param kwargs:
:return:
"""
if package == "keras":
from .keras import run_keras_training as run_training
elif package == "pytorch":
from .pytorch import run_pytorch_training as run_training
else:
raise RuntimeError("{} package is not supported".format(package))
return run_training(*args, **kwargs)
| 557 | 30 | 93 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/utils/filenames.py | import os
from functools import partial, update_wrapper
from unet3d.utils import sequences as keras_sequences
from unet3d.utils.pytorch import dataset as pytorch_datasets
from unet3d.utils.utils import load_image, load_json, in_config
unet3d_path = os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
def wrapped_partial(func, *args, **kwargs):
partial_func = partial(func, *args, **kwargs)
update_wrapper(partial_func, func)
return partial_func
def generate_hcp_filenames(directory, surface_basename_template, target_basenames, feature_basenames, subject_ids,
hemispheres):
rows = list()
for subject_id in subject_ids:
subject_id = str(subject_id)
subject_dir = os.path.join(directory, subject_id)
if type(feature_basenames) == str:
feature_filenames = os.path.join(subject_dir, feature_basenames)
if not os.path.exists(feature_filenames):
continue
else:
feature_filenames = [os.path.join(subject_dir, fbn) for fbn in feature_basenames]
if surface_basename_template is not None:
surface_filenames = [os.path.join(subject_dir,
surface_basename_template.format(hemi=hemi, subject_id=subject_id))
for hemi in hemispheres]
else:
surface_filenames = None
if type(target_basenames) == str:
metric_filenames = os.path.join(subject_dir, target_basenames)
if "{}" in metric_filenames:
metric_filenames = metric_filenames.format(subject_id)
if not os.path.exists(metric_filenames):
continue
elif target_basenames is not None:
metric_filenames = [os.path.join(subject_dir, mbn.format(subject_id)) for mbn in target_basenames]
else:
metric_filenames = None
rows.append([feature_filenames, surface_filenames, metric_filenames, subject_id])
return rows
def generate_paired_filenames(directory, subject_ids, group, keys, basename, additional_feature_basename=None,
raise_if_not_exists=False):
rows = list()
pair = keys["all"]
pair_key = list(keys["all"].keys())[0]
volume_numbers = dict()
for subject_id in subject_ids:
subject_id = str(subject_id)
template = os.path.join(directory, subject_id, basename)
if additional_feature_basename is not None:
additional_feature_filename = os.path.join(directory, subject_id, additional_feature_basename)
if not os.path.exists(additional_feature_filename):
if raise_if_not_exists:
raise FileNotFoundError(additional_feature_filename)
continue
else:
additional_feature_filename = None
for key in keys[group]:
for value in keys[group][key]:
format_kwargs1 = {key: value, pair_key: pair[pair_key][0]}
format_kwargs2 = {key: value, pair_key: pair[pair_key][1]}
filename1 = template.format(**format_kwargs1)
filename2 = template.format(**format_kwargs2)
if os.path.exists(filename1) and os.path.exists(filename2):
if value not in volume_numbers:
volume_numbers[value] = range(load_image(filename1, force_4d=True).shape[-1])
for volume_number in volume_numbers[value]:
if additional_feature_filename is not None:
rows.append([[additional_feature_filename, filename1], [0, volume_number + 1],
filename2, [volume_number], subject_id])
rows.append([[additional_feature_filename, filename2], [0, volume_number + 1],
filename1, [volume_number], subject_id])
else:
rows.append([filename1, [volume_number], filename2, [volume_number], subject_id])
rows.append([filename2, [volume_number], filename1, [volume_number], subject_id])
elif raise_if_not_exists:
for filename in (filename1, filename2):
raise FileNotFoundError(filename)
return rows
def format_templates(templates, directory="", **kwargs):
if type(templates) == str:
return os.path.join(directory, templates).format(**kwargs)
else:
return [os.path.join(directory, template).format(**kwargs) for template in templates]
def exists(filenames):
if type(filenames) == str:
filenames = [filenames]
return all([os.path.exists(filename) for filename in filenames])
def generate_filenames_from_templates(subject_ids, feature_templates, target_templates=None, feature_sub_volumes=None,
target_sub_volumes=None, raise_if_not_exists=False, directory="",
skip_targets=False):
filenames = list()
for subject_id in subject_ids:
feature_filename = format_templates(feature_templates, directory=directory, subject=subject_id)
if skip_targets:
target_filename = None
else:
target_filename = format_templates(target_templates, directory=directory, subject=subject_id)
if feature_sub_volumes is not None:
_feature_sub_volumes = feature_sub_volumes
else:
_feature_sub_volumes = None
if target_sub_volumes is not None:
_target_sub_volumes = target_sub_volumes
else:
_target_sub_volumes = None
if exists(feature_filename) and (skip_targets or exists(target_filename)):
filenames.append([feature_filename, _feature_sub_volumes, target_filename, _target_sub_volumes, subject_id])
elif raise_if_not_exists:
for filename in (feature_filename, target_filename):
if not exists(filename):
raise FileNotFoundError(filename)
return filenames
def generate_filenames_from_multisource_templates(subject_ids, feature_templates, target_templates,
feature_sub_volumes=None, target_sub_volumes=None,
raise_if_not_exists=False, directory=""):
filenames = dict()
for dataset in subject_ids:
filenames[dataset] = generate_filenames_from_templates(subject_ids[dataset],
feature_templates[dataset],
target_templates[dataset],
(feature_sub_volumes[dataset]
if feature_sub_volumes is not None else None),
(target_sub_volumes[dataset]
if target_sub_volumes is not None else None),
raise_if_not_exists=raise_if_not_exists,
directory=directory)
return filenames
def generate_filenames(config, name, directory="", skip_targets=False, raise_if_not_exists=False):
if name not in config:
load_subject_ids(config, name)
if "generate_filenames" not in config or config["generate_filenames"] == "classic":
return generate_hcp_filenames(directory,
config['surface_basename_template']
if "surface_basename_template" in config else None,
config['target_basenames'],
config['feature_basenames'],
config[name],
config['hemispheres'] if 'hemispheres' in config else None)
elif config["generate_filenames"] == "paired":
return generate_paired_filenames(directory,
config[name],
name,
raise_if_not_exists=raise_if_not_exists,
**config["generate_filenames_kwargs"])
elif config["generate_filenames"] == "multisource_templates":
return generate_filenames_from_multisource_templates(config[name],
raise_if_not_exists=raise_if_not_exists,
**config["generate_filenames_kwargs"])
elif config["generate_filenames"] == "templates":
return generate_filenames_from_templates(config[name],
raise_if_not_exists=raise_if_not_exists,
**config["generate_filenames_kwargs"],
skip_targets=skip_targets)
def load_subject_ids(config, name):
if "subjects_filename" in config:
subjects = load_json(os.path.join(unet3d_path, config["subjects_filename"]))
config[name] = subjects[name]
def load_bias(bias_filename):
import numpy as np
return np.fromfile(os.path.join(unet3d_path, bias_filename))
def load_sequence(sequence_name):
try:
sequence_class = getattr(keras_sequences, sequence_name)
except AttributeError as error:
sequence_class = getattr(pytorch_datasets, sequence_name)
return sequence_class | 9,790 | 50.26178 | 120 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/utils/sequences.py | import os
from functools import partial
import numpy as np
import nibabel as nib
from nilearn.image import new_img_like, resample_to_img, reorder_img
import random
import warnings
from .nilearn_custom_utils.nilearn_utils import crop_img
from .radiomic_utils import binary_classification, multilabel_classification, fetch_data, fetch_data_for_point
from .hcp import (extract_gifti_surface_vertices, get_vertices_from_scalar, get_metric_data,
extract_cifti_volumetric_data)
from .utils import (copy_image, extract_sub_volumes, mask,
compile_one_hot_encoding,
nib_load_files, load_image, load_single_image,
get_nibabel_data, add_one_hot_encoding_contours)
from .normalize import zero_mean_normalize_image_data, foreground_zero_mean_normalize_image_data, \
zero_floor_normalize_image_data, zero_one_window
from . import normalize
from .resample import resample
from .augment import scale_affine, add_noise, affine_swap_axis, translate_affine, random_blur, random_permutation_x_y
from .affine import resize_affine
class Sequence(object):
"""
Based off of keras.utils.Sequence
"""
def __getitem__(self, index):
raise NotImplementedError
def __len__(self):
raise NotImplementedError
def on_epoch_end(self):
pass
def __iter__(self):
for item in (self[i] for i in range(len(self))):
yield item
def normalization_name_to_function(normalization_name):
if type(normalization_name) == list:
return partial(normalize_data_with_multiple_functions, normalization_names=normalization_name)
elif normalization_name == "zero_mean":
return zero_mean_normalize_image_data
elif normalization_name == "foreground_zero_mean":
return foreground_zero_mean_normalize_image_data
elif normalization_name == "zero_floor":
return zero_floor_normalize_image_data
elif normalization_name == "zero_one_window":
return zero_one_window
elif normalization_name == "mask":
return mask
elif normalization_name is not None:
try:
return getattr(normalize, normalization_name)
except AttributeError:
raise NotImplementedError(normalization_name + " normalization is not available.")
else:
return lambda x, **kwargs: x
def normalize_image_with_function(image, function, volume_indices=None, **kwargs):
data = get_nibabel_data(image)
if volume_indices is not None:
data[..., volume_indices] = function(data[..., volume_indices], **kwargs)
else:
data = function(data, **kwargs)
return new_img_like(image, data=data, affine=image.affine)
def normalize_data_with_multiple_functions(data, normalization_names, channels_axis=3, **kwargs):
"""
:param data:
:param normalization_names:
:param channels_axis:
:param kwargs: sets the normalization parameters, but should have multiple sets of parameters for the individual
normalization functions.
:return:
"""
normalized_data = list()
for name in normalization_names:
func = normalization_name_to_function(name)
_kwargs = dict(kwargs[name]) if name in kwargs else None
if _kwargs and "volume_indices" in _kwargs and _kwargs["volume_indices"] is not None:
volume_indices = _kwargs.pop("volume_indices")
_data = data[..., volume_indices]
else:
_data = data
normalized_data.append(func(_data, **_kwargs))
return np.concatenate(normalized_data, axis=channels_axis)
def augment_affine(affine, shape, augment_scale_std=None, augment_scale_probability=1,
flip_left_right_probability=0, augment_translation_std=None, augment_translation_probability=1,
flip_front_back_probability=0):
if augment_scale_std and decision(augment_scale_probability):
scale = np.random.normal(1, augment_scale_std, 3)
affine = scale_affine(affine, shape, scale)
if decision(flip_left_right_probability): # flips the left and right sides of the image randomly
affine = affine_swap_axis(affine, shape=shape, axis=0)
if decision(flip_front_back_probability):
affine = affine_swap_axis(affine, shape=shape, axis=1)
if augment_translation_std and decision(augment_translation_probability):
affine = translate_affine(affine, shape,
translation_scales=np.random.normal(loc=0, scale=augment_translation_std, size=3))
return affine
def augment_image(image, augment_blur_mean=None, augment_blur_std=None, augment_blur_probability=1,
additive_noise_std=None, additive_noise_probability=1):
if not (augment_blur_mean is None or augment_blur_std is None) and decision(augment_blur_probability):
image = random_blur(image, mean=augment_blur_mean, std=augment_blur_std)
if additive_noise_std and decision(additive_noise_probability):
image.dataobj[:] = add_noise(image.dataobj, sigma_factor=additive_noise_std)
return image
def format_feature_image(feature_image, window, crop=False, cropping_kwargs=None, augment_scale_std=None,
augment_scale_probability=1, additive_noise_std=None, additive_noise_probability=0,
flip_left_right_probability=0, augment_translation_std=None,
augment_translation_probability=0, augment_blur_mean=None, augment_blur_std=None,
augment_blur_probability=0, flip_front_back_probability=0, reorder=False,
interpolation="linear"):
if reorder:
feature_image = reorder_img(feature_image, resample=interpolation)
if crop:
if cropping_kwargs is None:
cropping_kwargs = dict()
affine, shape = crop_img(feature_image, return_affine=True, **cropping_kwargs)
else:
affine = feature_image.affine.copy()
shape = feature_image.shape
affine = augment_affine(affine, shape,
augment_scale_std=augment_scale_std,
augment_scale_probability=augment_scale_probability,
augment_translation_std=augment_translation_std,
augment_translation_probability=augment_translation_probability,
flip_left_right_probability=flip_left_right_probability,
flip_front_back_probability=flip_front_back_probability)
feature_image = augment_image(feature_image,
augment_blur_mean=augment_blur_mean,
augment_blur_std=augment_blur_std,
augment_blur_probability=augment_blur_probability,
additive_noise_std=additive_noise_std,
additive_noise_probability=additive_noise_probability)
affine = resize_affine(affine, shape, window)
return feature_image, affine
def decision(probability):
if not probability or probability <= 0:
return False
elif probability >= 1:
return True
else:
return random.random() < probability
class BaseSequence(Sequence):
def __init__(self, filenames, batch_size, target_labels, window, spacing, classification='binary', shuffle=True,
points_per_subject=1, flip=False, reorder=False, iterations_per_epoch=1, deformation_augmentation=None,
base_directory=None, subject_ids=None, inputs_per_epoch=None, channel_axis=3,
verbose=False):
self.deformation_augmentation = deformation_augmentation
self.base_directory = base_directory
self.subject_ids = subject_ids
self.batch_size = batch_size
self.shuffle = shuffle
self.filenames = filenames
self.inputs_per_epoch = inputs_per_epoch
if self.inputs_per_epoch is not None:
if not type(self.filenames) == dict:
raise ValueError("'inputs_per_epoch' is not None, but 'filenames' is not a dictionary.")
self.filenames_dict = self.filenames
else:
self.filenames_dict = None
self.target_labels = target_labels
self.window = window
self.points_per_subject = points_per_subject
self.flip = flip
self.reorder = reorder
self.spacing = spacing
self.verbose = verbose
self.iterations_per_epoch = iterations_per_epoch
self.subjects_per_batch = int(np.floor(self.batch_size / self.points_per_subject))
assert self.subjects_per_batch > 0
if classification == 'binary':
self._classify = binary_classification
elif classification == 'multilabel':
self._classify = multilabel_classification
else:
self._classify = classification
self.channel_axis = channel_axis
self.on_epoch_end()
def get_number_of_subjects_per_epoch(self):
return self.get_number_of_subjects() * self.iterations_per_epoch
def get_number_of_subjects(self):
return len(self.filenames)
def generate_epoch_filenames(self):
if self.inputs_per_epoch is not None:
self.sample_filenames()
_filenames = list(self.filenames)
epoch_filenames = list()
for i in range(self.iterations_per_epoch):
if self.shuffle:
np.random.shuffle(_filenames)
epoch_filenames.extend(_filenames)
self.epoch_filenames = list(epoch_filenames)
def switch_to_augmented_filename(self, subject_id, filename):
augmented_filename = self.deformation_augmentation.format(base_directory=self.base_directory,
random_subject_id=np.random.choice(self.subject_ids),
subject_id=subject_id,
basename=os.path.basename(filename))
if not os.path.exists(augmented_filename):
raise RuntimeWarning("Augmented filename {} does not exists!".format(augmented_filename))
else:
filename = augmented_filename
return filename
def __len__(self):
return self.get_number_of_batches_per_epoch()
def get_number_of_batches_per_epoch(self):
return int(np.floor(np.divide(self.get_number_of_subjects_per_epoch(),
self.subjects_per_batch)))
def __getitem__(self, idx):
batch_filenames = self.epoch_filenames[idx * self.subjects_per_batch:(idx + 1) * self.subjects_per_batch]
batch_x = list()
batch_y = list()
for feature_filename, target_filename in batch_filenames:
for x, y in zip(*fetch_data(feature_filename,
target_filename,
self.target_labels,
self.window,
n_points=self.points_per_subject,
flip=self.flip,
reorder=self.reorder,
spacing=self.spacing,
classify=self._classify)):
batch_x.append(x)
batch_y.append(y)
return np.asarray(batch_x), np.asarray(batch_y)
def on_epoch_end(self):
self.generate_epoch_filenames()
def sample_filenames(self):
"""
Sample the filenames.
"""
filenames = list()
for key in self.filenames_dict:
if self.inputs_per_epoch[key] == "all":
filenames.extend(self.filenames_dict[key])
else:
_filenames = list(self.filenames_dict[key])
np.random.shuffle(_filenames)
filenames.extend(_filenames[:self.inputs_per_epoch[key]])
self.filenames = filenames
class HCPParent(object):
def __init__(self, surface_names, window, flip, reorder, spacing):
self.surface_names = surface_names
self.reorder = reorder
self.flip = flip
self.spacing = spacing
self.window = window
def extract_vertices(self, surface_filenames, metrics):
# extract the vertices
surfaces = nib_load_files(surface_filenames)
vertices = list()
for surface, surface_name in zip(surfaces, self.surface_names):
vertices_index = get_vertices_from_scalar(metrics[0], brain_structure_name=surface_name)
surface_vertices = extract_gifti_surface_vertices(surface, primary_anatomical_structure=surface_name)
vertices.extend(surface_vertices[vertices_index])
return np.asarray(vertices)
class HCPRegressionSequence(BaseSequence, HCPParent):
def __init__(self, filenames, batch_size, window, spacing, metric_names, classification=None,
surface_names=('CortexLeft', 'CortexRight'), normalization="zero_mean", normalization_args=None,
**kwargs):
super().__init__(filenames=filenames, batch_size=batch_size, target_labels=tuple(), window=window,
spacing=spacing, classification=classification, **kwargs)
self.metric_names = metric_names
self.surface_names = surface_names
self.normalize = normalization is not None
self.normalization_func = normalization_name_to_function(normalization)
if normalization_args is not None:
self.normalization_kwargs = normalization_args
else:
self.normalization_kwargs = dict()
def __getitem__(self, idx):
return self.fetch_hcp_regression_batch(idx)
def fetch_hcp_regression_batch(self, idx):
batch_filenames = self.epoch_filenames[idx * self.subjects_per_batch:(idx + 1) * self.subjects_per_batch]
batch_x = list()
batch_y = list()
for args in batch_filenames:
_x, _y = self.fetch_hcp_subject_batch(*args)
batch_x.extend(_x)
batch_y.extend(_y)
return np.asarray(batch_x), np.asarray(batch_y)
def load_metric_data(self, metric_filenames, subject_id):
metrics = nib_load_files(metric_filenames)
all_metric_data = get_metric_data(metrics, self.metric_names, self.surface_names, subject_id)
return metrics, all_metric_data
def load_feature_data(self, feature_filename, vertices, target_values):
batch_x = list()
batch_y = list()
feature_image = load_single_image(feature_filename, reorder=self.reorder)
for vertex, y in zip(vertices, target_values):
x = fetch_data_for_point(vertex, feature_image, window=self.window, flip=self.flip,
spacing=self.spacing)
batch_x.append(x)
batch_y.append(y)
return batch_x, batch_y
def fetch_hcp_subject_batch(self, feature_filename, surface_filenames, metric_filenames, subject_id):
metrics, all_metric_data = self.load_metric_data(metric_filenames, subject_id)
vertices = self.extract_vertices(surface_filenames, metrics)
random_vertices, random_target_values = self.select_random_vertices_and_targets(vertices, all_metric_data)
return self.load_feature_data(feature_filename, random_vertices, random_target_values)
def select_random_vertices(self, vertices):
indices = np.random.choice(np.arange(vertices.shape[0]), size=self.points_per_subject, replace=False)
random_vertices = vertices[indices]
return random_vertices, indices
def select_random_vertices_and_targets(self, vertices, all_metric_data):
# randomly select the target vertices and corresponding values
random_vertices, indices = self.select_random_vertices(vertices)
random_target_values = all_metric_data[indices]
return random_vertices, random_target_values
def normalize_image(self, image):
if self.normalize:
return normalize_image_with_function(image, self.normalization_func, **self.normalization_kwargs)
return image
class ParcelBasedSequence(HCPRegressionSequence):
def __init__(self, *args, target_parcel, parcellation_template, parcellation_name, **kwargs):
self.target_parcel = target_parcel
self.parcellation_template = parcellation_template
self.parcellation_name = parcellation_name
super().__init__(*args, **kwargs)
def fetch_hcp_subject_batch(self, feature_filename, surface_filenames, metric_filenames, subject_id):
metrics, all_metric_data = self.load_metric_data(metric_filenames, subject_id)
vertices = self.extract_vertices(surface_filenames, metrics)
parcellation = self.load_parcellation(subject_id)
parcellation_mask = np.in1d(parcellation, self.target_parcel)
random_vertices, random_target_values = self.select_random_vertices_and_targets(
vertices[parcellation_mask], all_metric_data[parcellation_mask])
return self.load_feature_data(feature_filename, random_vertices, random_target_values)
def load_parcellation(self, subject_id):
parcellation_filename = self.parcellation_template.format(subject_id)
parcellation = np.squeeze(get_metric_data(metrics=nib_load_files([parcellation_filename]),
metric_names=[[self.parcellation_name]],
surface_names=self.surface_names,
subject_id=subject_id))
return parcellation
class SubjectPredictionSequence(HCPParent, Sequence):
def __init__(self, feature_filename, surface_filenames, surface_names, reference_metric_filename,
batch_size=50, window=(64, 64, 64), flip=False, spacing=(1, 1, 1), reorder=False):
super().__init__(surface_names=surface_names, window=window, flip=flip, reorder=reorder, spacing=spacing)
self.feature_image = load_single_image(feature_filename, reorder=self.reorder)
self.reference_metric = nib.load(reference_metric_filename)
self.vertices = self.extract_vertices(surface_filenames=surface_filenames, metrics=[self.reference_metric])
self.batch_size = batch_size
def __len__(self):
return int(np.ceil(np.divide(len(self.vertices), self.batch_size)))
def __getitem__(self, idx):
batch_vertices = self.vertices[idx * self.batch_size:(idx + 1) * self.batch_size]
batch = [fetch_data_for_point(vertex,
self.feature_image,
window=self.window,
flip=self.flip,
spacing=self.spacing) for vertex in batch_vertices]
return np.asarray(batch)
class WholeVolumeToSurfaceSequence(HCPRegressionSequence):
def __init__(self, interpolation='linear', crop=True, cropping_kwargs=None,
augment_scale_std=0, augment_scale_probability=1, additive_noise_std=0, additive_noise_probability=1,
augment_blur_mean=None, augment_blur_std=None, augment_blur_probability=1,
augment_translation_std=None, augment_translation_probability=1, flip_left_right_probability=0,
flip_front_back_probability=0, resample=None, dtype=None, **kwargs):
"""
:param interpolation: interpolation to use when formatting the feature image.
:param crop: if true, images will be cropped to remove the background from the feature image.
:param cropping_pad_width: width of the padding around the foreground after cropping.
:param augment_scale_std: randomly augment the scale with this standard deviation (mean of 1). If None, 0 or
False, no augmentation will be done.
:param augment_scale_probability: If the scale augmentation is set, randomly pick when to implement.
:param additive_noise_std:
:param additive_noise_probability:
:param augment_blur_mean:
:param augment_blur_std:
:param augment_blur_probability:
:param augment_translation_std:
:param augment_translation_probability:
:param flip_left_right_probability:
:param resample: deprecated
:param kwargs:
"""
super().__init__(**kwargs)
self.interpolation = interpolation
if resample is not None:
warnings.warn("'resample' argument is deprecated. Use 'interpolation'.", DeprecationWarning)
self.crop = crop
self.augment_scale_std = augment_scale_std
self.augment_scale_probability = augment_scale_probability
self.additive_noise_std = additive_noise_std
self.additive_noise_probability = additive_noise_probability
self.cropping_kwargs = cropping_kwargs
self.augment_blur_mean = augment_blur_mean
self.augment_blur_std = augment_blur_std
self.augment_blur_probability = augment_blur_probability
self.augment_translation_std = augment_translation_std
self.augment_translation_probability = augment_translation_probability
self.flip_left_right_probability = flip_left_right_probability
self.flip_front_back_probability = flip_front_back_probability
self.dtype = dtype
def __len__(self):
return int(np.ceil(np.divide(len(self.epoch_filenames), self.batch_size)))
def __getitem__(self, idx):
x = list()
y = list()
batch_filenames = self.epoch_filenames[idx * self.batch_size:(idx + 1) * self.batch_size]
for feature_filename, surface_filenames, metric_filenames, subject_id in batch_filenames:
if self.deformation_augmentation:
feature_filename = self.switch_to_augmented_filename(subject_id=subject_id, filename=feature_filename)
metrics = nib_load_files(metric_filenames)
x.append(self.resample_input(feature_filename))
y.append(get_metric_data(metrics, self.metric_names, self.surface_names, subject_id).T.ravel())
return np.asarray(x), np.asarray(y)
def resample_input(self, feature_filename):
feature_image = load_image(feature_filename, reorder=False, verbose=self.verbose)
feature_image, affine = format_feature_image(feature_image=feature_image, window=self.window, crop=self.crop,
cropping_kwargs=self.cropping_kwargs,
augment_scale_std=self.augment_scale_std,
augment_scale_probability=self.augment_scale_probability,
additive_noise_std=self.additive_noise_std,
additive_noise_probability=self.additive_noise_probability,
augment_blur_mean=self.augment_blur_mean,
augment_blur_std=self.augment_blur_std,
augment_blur_probability=self.augment_blur_probability,
flip_left_right_probability=self.flip_left_right_probability,
flip_front_back_probability=self.flip_front_back_probability,
augment_translation_std=self.augment_translation_std,
augment_translation_probability=self.augment_translation_probability,
reorder=self.reorder,
interpolation=self.interpolation)
input_img = resample(feature_image, affine, self.window, interpolation=self.interpolation)
return get_nibabel_data(self.normalize_image(input_img))
class WholeVolumeAutoEncoderSequence(WholeVolumeToSurfaceSequence):
def __init__(self, *args, target_interpolation=None, target_index=None, feature_index=0, extract_sub_volumes=False,
feature_sub_volumes_index=1, target_sub_volumes_index=3, random_permutation_probability=0, **kwargs):
"""
:param args:
:param target_interpolation:
:param target_index:
:param feature_index:
:param extract_sub_volumes: if True, the sequence will expect a set of indices that will be used to extract
specific volumes out of the volumes being read. (default=False)
:param kwargs:
"""
super().__init__(*args, **kwargs)
if target_interpolation is None:
self.target_interpolation = self.interpolation
else:
self.target_interpolation = target_interpolation
self.target_index = target_index
self.feature_index = feature_index
self.extract_sub_volumes = extract_sub_volumes
self.feature_sub_volumes_index = feature_sub_volumes_index
self.target_sub_volumes_index = target_sub_volumes_index
self.random_permutation_probability = random_permutation_probability
def __getitem__(self, idx):
x_batch = list()
y_batch = list()
batch_filenames = self.epoch_filenames[idx * self.batch_size:(idx + 1) * self.batch_size]
for item in batch_filenames:
x, y = self.resample_input(item)
x_batch.append(x)
y_batch.append(y)
return np.asarray(x_batch), np.asarray(y_batch)
def resample_input(self, input_filenames):
input_image, target_image = self.resample_image(input_filenames)
x, y = get_nibabel_data(input_image), get_nibabel_data(target_image)
return self.permute_inputs(x, y)
def permute_inputs(self, x, y):
if decision(self.random_permutation_probability):
x, y = random_permutation_x_y(x, y, channel_axis=self.channel_axis)
return x, y
def resample_image(self, input_filenames):
feature_image = self.format_feature_image(input_filenames=input_filenames)
target_image = self.resample_target(self.load_target_image(feature_image, input_filenames),
feature_image)
feature_image = augment_image(feature_image,
additive_noise_std=self.additive_noise_std,
additive_noise_probability=self.additive_noise_probability,
augment_blur_mean=self.augment_blur_mean,
augment_blur_std=self.augment_blur_std,
augment_blur_probability=self.augment_blur_probability)
return feature_image, target_image
def load_image(self, filenames, index, force_4d=True, interpolation="linear", sub_volume_indices=None):
filename = filenames[index]
# Reordering is done when the image is formatted
image = load_image(filename, force_4d=force_4d, reorder=False, interpolation=interpolation, dtype=self.dtype,
verbose=self.verbose)
if sub_volume_indices:
image = extract_sub_volumes(image, sub_volume_indices)
return image
def load_feature_image(self, input_filenames):
if self.extract_sub_volumes:
sub_volume_indices = input_filenames[self.feature_sub_volumes_index]
else:
sub_volume_indices = None
return self.load_image(input_filenames, self.feature_index, force_4d=True, interpolation=self.interpolation,
sub_volume_indices=sub_volume_indices)
def format_feature_image(self, input_filenames, return_unmodified=False):
unmodified_image = self.load_feature_image(input_filenames)
image, affine = format_feature_image(feature_image=self.normalize_image(unmodified_image),
crop=self.crop,
cropping_kwargs=self.cropping_kwargs,
augment_scale_std=self.augment_scale_std,
augment_scale_probability=self.augment_scale_probability,
window=self.window,
additive_noise_std=None, # augmented later
augment_blur_mean=None, # augmented later
augment_blur_std=None, # augmented later
flip_left_right_probability=self.flip_left_right_probability,
flip_front_back_probability=self.flip_front_back_probability,
augment_translation_std=self.augment_translation_std,
augment_translation_probability=self.augment_translation_probability,
reorder=self.reorder,
interpolation=self.interpolation)
resampled = resample(image, affine, self.window, interpolation=self.interpolation)
if return_unmodified:
return resampled, unmodified_image
else:
return resampled
def load_target_image(self, feature_image, input_filenames):
if self.target_index is None:
target_image = copy_image(feature_image)
else:
if self.extract_sub_volumes:
sub_volume_indices = input_filenames[self.target_sub_volumes_index]
else:
sub_volume_indices = None
target_image = self.load_image(input_filenames, self.target_index, force_4d=True,
sub_volume_indices=sub_volume_indices,
interpolation=self.target_interpolation)
return target_image
def resample_target(self, target_image, feature_image):
target_image = resample_to_img(target_image, feature_image, interpolation=self.target_interpolation)
return target_image
def get_image(self, idx):
input_image, target_image = self.resample_image(self.epoch_filenames[idx])
return input_image, target_image
def get_feature_image(self, idx, return_unmodified=False):
return self.format_feature_image(self.epoch_filenames[idx], return_unmodified=return_unmodified)
class WholeVolumeSegmentationSequence(WholeVolumeAutoEncoderSequence):
def __init__(self, *args, target_interpolation="nearest", target_index=2, labels=None, add_contours=False,
**kwargs):
super().__init__(*args, **kwargs)
self.target_interpolation = target_interpolation
self.target_index = target_index
self.labels = labels
self.add_contours = add_contours
def resample_input(self, input_filenames):
input_image, target_image = self.resample_image(input_filenames)
target_data = get_nibabel_data(target_image)
assert len(target_data.shape) == 4
if target_data.shape[3] == 1:
if self.labels is None:
self.labels = np.asarray(np.unique(target_data)[1:], dtype=int)
target_data = np.moveaxis(
compile_one_hot_encoding(np.moveaxis(target_data, 3, 0),
n_labels=len(self.labels),
labels=self.labels,
return_4d=True), 0, 3)
else:
if self.labels is None:
self.labels = np.asarray([np.unique(target_data[:, :, :, channel])[1:]
for channel in np.arange(target_data.shape[self.channel_axis])],
dtype=int)
_target_data = list()
for channel, labels in zip(range(target_data.shape[self.channel_axis]), self.labels):
if type(labels) != list:
labels = [labels]
_target_data.append(np.moveaxis(
compile_one_hot_encoding(np.moveaxis(target_data[..., channel, None], self.channel_axis, 0),
n_labels=len(labels),
labels=labels,
return_4d=True), 0, self.channel_axis))
target_data = np.concatenate(_target_data, axis=self.channel_axis)
if self.add_contours:
target_data = add_one_hot_encoding_contours(target_data)
return self.permute_inputs(get_nibabel_data(input_image), target_data)
class WindowedAutoEncoderSequence(HCPRegressionSequence):
def __init__(self, *args, resample="linear", additive_noise_std=0, **kwargs):
super().__init__(*args, **kwargs)
self.additive_noise_std = additive_noise_std
self.resample = resample
def fetch_hcp_subject_batch(self, feature_filename, surface_filenames, metric_filenames, subject_id):
surfaces = nib_load_files(surface_filenames)
vertices = list()
for surface, surface_name in zip(surfaces, self.surface_names):
vertices.extend(extract_gifti_surface_vertices(surface, primary_anatomical_structure=surface_name))
random_vertices, _ = self.select_random_vertices(np.asarray(vertices))
return self.load_feature_data_without_metrics(feature_filename, random_vertices)
def load_feature_data_without_metrics(self, feature_filename, random_vertices):
batch_x = list()
batch_y = list()
feature_image = load_single_image(feature_filename, resample=self.resample, reorder=self.reorder)
normalized_image = self.normalize_image(feature_image)
for vertex in random_vertices:
x = fetch_data_for_point(vertex, normalized_image, window=self.window, flip=self.flip, spacing=self.spacing,
normalization_func=None)
batch_x.append(self.augment(x))
batch_y.append(x)
return batch_x, batch_y
def augment(self, x):
if self.additive_noise_std > 0:
x = add_noise(x, sigma_factor=self.additive_noise_std)
return x
class WholeVolumeSupervisedRegressionSequence(WholeVolumeAutoEncoderSequence):
def __init__(self, *args, target_normalization=None, target_interpolation=None, target_index=2, **kwargs):
super().__init__(*args, target_index=target_index, target_interpolation=target_interpolation, **kwargs)
self.normalize_target = target_normalization is not None
self.target_normalization_func = normalization_name_to_function(target_normalization)
def load_target_image(self, feature_image, input_filenames, resample=False):
target_image = super().load_target_image(feature_image, input_filenames)
if self.normalize_target:
image_data = self.target_normalization_func(target_image.get_fdata())
return new_img_like(ref_niimg=feature_image, data=image_data,
affine=target_image.header.affine)
else:
return target_image
class WholeVolumeCiftiSupervisedRegressionSequence(WholeVolumeSupervisedRegressionSequence):
def __init__(self, *args, target_normalization=None, target_interpolation=None, target_index=2,
subject_id_index=3, **kwargs):
super().__init__(*args, target_index=target_index, target_interpolation=target_interpolation,
target_normalization=target_normalization, **kwargs)
self.subject_id_index = subject_id_index
def load_target_image(self, feature_image, input_filenames, reorder=False):
target_image_filename = input_filenames[self.target_index]
cifti_target_image = nib.load(target_image_filename)
image_data = extract_cifti_volumetric_data(cifti_image=cifti_target_image,
map_names=self.metric_names,
subject_id=input_filenames[self.subject_id_index])
image_data = self.target_normalization_func(image_data)
return new_img_like(ref_niimg=feature_image, data=image_data,
affine=cifti_target_image.header.get_axis(1).affine)
| 36,756 | 50.625 | 122 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/utils/pytorch/ssim.py | # Modified from https://github.com/VainF/pytorch-msssim
import torch
import torch.nn.functional as F
def _fspecial_gauss_1d(size, sigma):
r"""Create 1-D gauss kernel
Args:
size (int): the size of gauss kernel
sigma (float): sigma of normal distribution
Returns:
torch.Tensor: 1D kernel
"""
coords = torch.arange(size).to(dtype=torch.float)
coords -= size//2
g = torch.exp(-(coords**2) / (2*sigma**2))
g /= g.sum()
return g.unsqueeze(0).unsqueeze(0)
def gaussian_filter(input, win):
r""" Blur input with 1-D kernel
Args:
input (torch.Tensor): a batch of tensors to be blured
window (torch.Tensor): 1-D gauss kernel
Returns:
torch.Tensor: blured tensors
"""
N, C, H, W = input.shape
out = F.conv2d(input, win, stride=1, padding=0, groups=C)
out = F.conv2d(out, win.transpose(2, 3), stride=1, padding=0, groups=C)
return out
def _ssim(X, Y, win, data_range=255, size_average=True, full=False, K=(0.01,0.03)):
r""" Calculate ssim index for X and Y
Args:
X (torch.Tensor): images
Y (torch.Tensor): images
win (torch.Tensor): 1-D gauss kernel
data_range (float or int, optional): value range of input images. (usually 1.0 or 255)
size_average (bool, optional): if size_average=True, ssim of all images will be averaged as a scalar
full (bool, optional): return sc or not
Returns:
torch.Tensor: ssim results
"""
K1, K2 = K
batch, channel, height, width = X.shape
compensation = 1.0
C1 = (K1 * data_range)**2
C2 = (K2 * data_range)**2
win = win.to(X.device, dtype=X.dtype)
mu1 = gaussian_filter(X, win)
mu2 = gaussian_filter(Y, win)
mu1_sq = mu1.pow(2)
mu2_sq = mu2.pow(2)
mu1_mu2 = mu1 * mu2
sigma1_sq = compensation * ( gaussian_filter(X * X, win) - mu1_sq )
sigma2_sq = compensation * ( gaussian_filter(Y * Y, win) - mu2_sq )
sigma12 = compensation * ( gaussian_filter(X * Y, win) - mu1_mu2 )
cs_map = (2 * sigma12 + C2) / (sigma1_sq + sigma2_sq + C2) # set alpha=beta=gamma=1
ssim_map = ((2 * mu1_mu2 + C1) / (mu1_sq + mu2_sq + C1)) * cs_map
if size_average:
ssim_val = ssim_map.mean()
cs = cs_map.mean()
else:
ssim_val = ssim_map.mean(-1).mean(-1).mean(-1) # reduce along CHW
cs = cs_map.mean(-1).mean(-1).mean(-1)
if full:
return ssim_val, cs
else:
return ssim_val
def ssim(X, Y, win_size=11, win_sigma=1.5, win=None, data_range=255, size_average=True, full=False, K=(0.01, 0.03)):
r""" interface of ssim
Args:
X (torch.Tensor): a batch of images, (N,C,H,W)
Y (torch.Tensor): a batch of images, (N,C,H,W)
win_size: (int, optional): the size of gauss kernel
win_sigma: (float, optional): sigma of normal distribution
win (torch.Tensor, optional): 1-D gauss kernel. if None, a new kernel will be created according to win_size and win_sigma
data_range (float or int, optional): value range of input images. (usually 1.0 or 255)
size_average (bool, optional): if size_average=True, ssim of all images will be averaged as a scalar
full (bool, optional): return sc or not
K (list or tuple, optional): scalar constants (K1, K2). Try a larger K2 constant (e.g. 0.4) if you get a negative or NaN results.
Returns:
torch.Tensor: ssim results
"""
if len(X.shape) != 4:
raise ValueError('Input images must be 4-d tensors.')
if not X.type() == Y.type():
raise ValueError('Input images must have the same dtype.')
if not X.shape == Y.shape:
raise ValueError('Input images must have the same dimensions.')
if not (win_size % 2 == 1):
raise ValueError('Window size must be odd.')
win_sigma = win_sigma
if win is None:
win = _fspecial_gauss_1d(win_size, win_sigma)
win = win.repeat(X.shape[1], 1, 1, 1)
else:
win_size = win.shape[-1]
ssim_val, cs = _ssim(X, Y,
win=win,
data_range=data_range,
size_average=False,
full=True, K=K)
if size_average:
ssim_val = ssim_val.mean()
cs = cs.mean()
if full:
return ssim_val, cs
else:
return ssim_val
def ms_ssim(X, Y, win_size=11, win_sigma=1.5, win=None, data_range=255, size_average=True, full=False, weights=None, K=(0.01, 0.03)):
r""" interface of ms-ssim
Args:
X (torch.Tensor): a batch of images, (N,C,H,W)
Y (torch.Tensor): a batch of images, (N,C,H,W)
win_size: (int, optional): the size of gauss kernel
win_sigma: (float, optional): sigma of normal distribution
win (torch.Tensor, optional): 1-D gauss kernel. if None, a new kernel will be created according to win_size and win_sigma
data_range (float or int, optional): value range of input images. (usually 1.0 or 255)
size_average (bool, optional): if size_average=True, ssim of all images will be averaged as a scalar
full (bool, optional): return sc or not
weights (list, optional): weights for different levels
K (list or tuple, optional): scalar constants (K1, K2). Try a larger K2 constant (e.g. 0.4) if you get a negative or NaN results.
Returns:
torch.Tensor: ms-ssim results
"""
if len(X.shape) != 4:
raise ValueError('Input images must be 4-obj tensors.')
if not X.type() == Y.type():
raise ValueError('Input images must have the same dtype.')
if not X.shape == Y.shape:
raise ValueError('Input images must have the same dimensions.')
if not (win_size % 2 == 1):
raise ValueError('Window size must be odd.')
if weights is None:
weights = torch.FloatTensor(
[0.0448, 0.2856, 0.3001, 0.2363, 0.1333]).to(X.device, dtype=X.dtype)
win_sigma = win_sigma
if win is None:
win = _fspecial_gauss_1d(win_size, win_sigma)
win = win.repeat(X.shape[1], 1, 1, 1)
else:
win_size = win.shape[-1]
levels = weights.shape[0]
mcs = []
for _ in range(levels):
ssim_val, cs = _ssim(X, Y,
win=win,
data_range=data_range,
size_average=False,
full=True, K=K)
mcs.append(cs)
padding = (X.shape[2] % 2, X.shape[3] % 2)
X = F.avg_pool2d(X, kernel_size=2, padding=padding)
Y = F.avg_pool2d(Y, kernel_size=2, padding=padding)
mcs = torch.stack(mcs, dim=0) # mcs, (level, batch)
# weights, (level)
msssim_val = torch.prod((mcs[:-1] ** weights[:-1].unsqueeze(1))
* (ssim_val ** weights[-1]), dim=0) # (batch, )
if size_average:
msssim_val = msssim_val.mean()
return msssim_val
class SSIM(torch.nn.Module):
def __init__(self, win_size=11, win_sigma=1.5, data_range=None, size_average=True, channel=3, K=(0.01, 0.03)):
r""" class for ssim
Args:
win_size: (int, optional): the size of gauss kernel
win_sigma: (float, optional): sigma of normal distribution
data_range (float or int, optional): value range of input images. (usually 1.0 or 255)
size_average (bool, optional): if size_average=True, ssim of all images will be averaged as a scalar
channel (int, optional): input channels (default: 3)
K (list or tuple, optional): scalar constants (K1, K2). Try a larger K2 constant (e.g. 0.4) if you get a
negative or NaN results.
"""
super(SSIM, self).__init__()
self.win = _fspecial_gauss_1d(
win_size, win_sigma).repeat(channel, 1, 1, 1)
self.size_average = size_average
self.data_range = data_range
self.K = K
def forward(self, X, Y):
return ssim(X, Y, win=self.win, data_range=self.data_range, size_average=self.size_average, K=self.K)
class MS_SSIM(torch.nn.Module):
def __init__(self, win_size=11, win_sigma=1.5, data_range=None, size_average=True, channel=3, weights=None,
K=(0.01, 0.03)):
r""" class for ms-ssim
Args:
win_size: (int, optional): the size of gauss kernel
win_sigma: (float, optional): sigma of normal distribution
data_range (float or int, optional): value range of input images. (usually 1.0 or 255)
size_average (bool, optional): if size_average=True, ssim of all images will be averaged as a scalar
channel (int, optional): input channels (default: 3)
weights (list, optional): weights for different levels
K (list or tuple, optional): scalar constants (K1, K2). Try a larger K2 constant (e.g. 0.4) if you get a
negative or NaN results.
"""
super(MS_SSIM, self).__init__()
self.win = _fspecial_gauss_1d(
win_size, win_sigma).repeat(channel, 1, 1, 1)
self.size_average = size_average
self.data_range = data_range
self.weights = weights
self.K = K
def forward(self, X, Y):
return ms_ssim(X, Y, win=self.win, size_average=self.size_average, data_range=self.data_range,
weights=self.weights, K=self.K)
class SSIMLoss5d(SSIM):
def __init__(self, *args, transpose=(-1, -3), **kwargs):
super(SSIMLoss5d, self).__init__(*args, **kwargs)
self.transpose = transpose
def forward(self, x, y):
if self.transpose:
x = x.transpose(*self.transpose)
y = y.transpose(*self.transpose)
return super(SSIMLoss5d, self).forward(x.view(-1, x.shape[-3], x.shape[-2], x.shape[-1]),
y.view(-1, y.shape[-3], y.shape[-2], y.shape[-1]))
class MSSSIMLoss5d(MS_SSIM):
def __init__(self, *args, transpose=(-1, -3), **kwargs):
super(MSSSIMLoss5d, self).__init__(*args, **kwargs)
self.transpose = transpose
def forward(self, x, y):
if self.transpose:
x = x.transpose(*self.transpose)
y = y.transpose(*self.transpose)
return super(MSSSIMLoss5d, self).forward(x.view(-1, x.shape[-3], x.shape[-2], x.shape[-1]),
y.view(-1, y.shape[-3], y.shape[-2], y.shape[-1]))
| 10,488 | 36.195035 | 137 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/utils/pytorch/functions.py | from torch.nn.functional import l1_loss, mse_loss
import torch
from .pt3dunet import compute_per_channel_dice
def per_channel_dice_loss(x, y, **kwargs):
return 1 - compute_per_channel_dice(x, y, **kwargs).mean()
def variational_regularized_loss(predicted, vae_x, mu, logvar, x, y, pred_loss=l1_loss, decoder_loss=mse_loss,
vae_weight=0.1, kl_weight=0.1):
loss_pred = pred_loss(predicted, y)
loss_vae = decoder_loss(vae_x, x)
N = x.numel()/x.shape[0]
loss_kl = (1 / N) * torch.sum(mu.pow(2) + logvar.exp() - logvar - 1)
return loss_pred + (vae_weight * loss_vae) + (kl_weight * loss_kl)
def regularized_loss(predicted_y, predicted_x, x, y, pred_loss=l1_loss, decoder_loss=mse_loss, decoder_weight=0.1):
return pred_loss(predicted_y, y) + decoder_weight * decoder_loss(predicted_x, x)
def kl_loss(mu, logvar, N):
return (1 / N) * torch.sum(mu.pow(2) + logvar.exp() - logvar - 1)
def vae_loss(predicted_x, mu, logvar, x, recon_loss=mse_loss, divergence_loss=kl_loss, recon_weight=1, kl_weight=1):
loss_recon = recon_loss(predicted_x, x)
loss_kl = divergence_loss(mu, logvar, x.numel()/x.shape[0])
return recon_weight * loss_recon + kl_weight * loss_kl
def dice_loss(input, target, smooth=1.):
iflat = input.view(-1).float()
tflat = target.view(-1).float()
intersection = (iflat * tflat).sum()
return 1 - ((2. * intersection + smooth)/(iflat.sum() + tflat.sum() + smooth))
def vae_dice_loss(predicted, mu, logvar, target, loss=dice_loss, divergence_loss=kl_loss, weight=1, kl_weight=1):
return vae_loss(predicted_x=predicted, mu=mu, logvar=logvar, x=target, recon_loss=loss,
divergence_loss=divergence_loss, recon_weight=weight, kl_weight=kl_weight)
def vae_l1_loss(predicted, mu, logvar, target, loss=l1_loss, divergence_loss=kl_loss, weight=1, kl_weight=1):
return vae_loss(predicted_x=predicted, mu=mu, logvar=logvar, x=target, recon_loss=loss,
divergence_loss=divergence_loss, recon_weight=weight, kl_weight=kl_weight)
def weighted_loss(input, target, weights, loss_func, weighted_dimension=1):
losses = torch.zeros(input.shape[weighted_dimension])
for index in range(input.shape[weighted_dimension]):
x = input.select(dim=weighted_dimension, index=index)
y = target.select(dim=weighted_dimension, index=index)
losses[index] = loss_func(x, y)
return torch.mean(weights * losses)
class WeightedLoss(object):
def __init__(self, weights, loss_func, weighted_dimension=1):
self.weights = weights
self.loss_func = loss_func
self.weighted_dimension = weighted_dimension
def __call__(self, input, target):
return weighted_loss(input=input, target=target, weights=self.weights, loss_func=self.loss_func,
weighted_dimension=self.weighted_dimension)
| 2,908 | 41.15942 | 116 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/utils/pytorch/dataset.py | from torch.utils.data import Dataset
import torch
import numpy as np
from ..sequences import (WholeVolumeToSurfaceSequence, HCPRegressionSequence, get_metric_data,
WholeVolumeAutoEncoderSequence, WholeVolumeSegmentationSequence, WindowedAutoEncoderSequence,
SubjectPredictionSequence, fetch_data_for_point, WholeVolumeCiftiSupervisedRegressionSequence,
WholeVolumeSupervisedRegressionSequence)
from ..utils import nib_load_files
class WholeBrainCIFTI2DenseScalarDataset(WholeVolumeToSurfaceSequence, Dataset):
def __init__(self, *args, batch_size=1, shuffle=False, **kwargs):
super().__init__(*args, batch_size=batch_size, shuffle=shuffle, **kwargs)
def __len__(self):
return len(self.epoch_filenames)
def __getitem__(self, idx):
feature_filename, surface_filenames, metric_filenames, subject_id = self.epoch_filenames[idx]
metrics = nib_load_files(metric_filenames)
x = self.resample_input(feature_filename)
y = self.get_metric_data(metrics, subject_id)
return torch.from_numpy(x).float().permute(3, 0, 1, 2), torch.from_numpy(y).float()
def get_metric_data(self, metrics, subject_id):
return get_metric_data(metrics, self.metric_names, self.surface_names, subject_id).T.ravel()
class HCPRegressionDataset(HCPRegressionSequence, Dataset):
def __init__(self, *args, points_per_subject=1, **kwargs):
super().__init__(*args, batch_size=points_per_subject, **kwargs)
def __len__(self):
return len(self.epoch_filenames)
def __getitem__(self, idx):
x, y = self.fetch_hcp_subject_batch(*self.epoch_filenames[idx])
return torch.from_numpy(np.moveaxis(np.asarray(x), -1, 1)).float(), torch.from_numpy(np.asarray(y)).float()
class HCPSubjectDataset(SubjectPredictionSequence):
def __init__(self, *args, batch_size=None, **kwargs):
if batch_size is not None:
print("Ignoring the set batch_size")
super().__init__(*args, batch_size=1, **kwargs)
def __getitem__(self, idx):
x = self.fetch_data_for_index(idx)
return torch.from_numpy(np.moveaxis(np.asarray(x), -1, 0)).float()
def __len__(self):
return len(self.vertices)
def fetch_data_for_index(self, idx):
return fetch_data_for_point(self.vertices[idx], self.feature_image, window=self.window, flip=self.flip,
spacing=self.spacing)
class AEDataset(WholeVolumeAutoEncoderSequence, Dataset):
def __init__(self, *args, batch_size=1, shuffle=False, metric_names=None, **kwargs):
super().__init__(*args, batch_size=batch_size, shuffle=shuffle, metric_names=metric_names, **kwargs)
def __len__(self):
return len(self.epoch_filenames)
def __getitem__(self, idx):
item = self.epoch_filenames[idx]
x, y = self.resample_input(item)
return (torch.from_numpy(np.moveaxis(np.asarray(x), -1, 0)).float(),
torch.from_numpy(np.moveaxis(np.asarray(y), -1, 0)).float())
class WholeVolumeSegmentationDataset(WholeVolumeSegmentationSequence, Dataset):
def __init__(self, *args, batch_size=1, shuffle=False, metric_names=None, **kwargs):
super().__init__(*args, batch_size=batch_size, shuffle=shuffle, metric_names=metric_names, **kwargs)
def __len__(self):
return len(self.epoch_filenames)
def __getitem__(self, idx):
item = self.epoch_filenames[idx]
x, y = self.resample_input(item)
return (torch.from_numpy(np.moveaxis(np.copy(x), -1, 0)).float(),
torch.from_numpy(np.moveaxis(np.copy(y), -1, 0)).byte())
class WholeVolumeSupervisedRegressionDataset(WholeVolumeSupervisedRegressionSequence, Dataset):
def __init__(self, *args, batch_size=1, shuffle=False, **kwargs):
super().__init__(*args, batch_size=batch_size, shuffle=shuffle, **kwargs)
def __len__(self):
return len(self.epoch_filenames)
def __getitem__(self, idx):
item = self.epoch_filenames[idx]
x, y = self.resample_input(item)
return (torch.from_numpy(np.moveaxis(np.asarray(x), -1, 0)).float(),
torch.from_numpy(np.moveaxis(np.asarray(y), -1, 0)).float())
class WholeVolumeCiftiSupervisedRegressionDataset(WholeVolumeCiftiSupervisedRegressionSequence,
WholeVolumeSupervisedRegressionDataset):
pass
class WindowedAEDataset(WindowedAutoEncoderSequence, Dataset):
def __init__(self, *args, points_per_subject=1, **kwargs):
super().__init__(*args, batch_size=points_per_subject, **kwargs)
def __len__(self):
return len(self.epoch_filenames)
def __getitem__(self, idx):
x, y = self.fetch_hcp_subject_batch(*self.epoch_filenames[idx])
return (torch.from_numpy(np.moveaxis(np.asarray(x), -1, 1)).float(),
torch.from_numpy(np.moveaxis(np.asarray(y), -1, 1)).float())
| 5,005 | 41.067227 | 119 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/utils/pytorch/pt3dunet.py | # from wolny's GitHub project: https://github.com/wolny/pytorch-3dunet
def compute_per_channel_dice(input, target, epsilon=1e-6, weight=None):
"""
Computes DiceCoefficient as defined in https://arxiv.org/abs/1606.04797 given a multi channel input and target.
Assumes the input is a normalized probability, e.g. a result of Sigmoid or Softmax function.
Args:
input (torch.Tensor): NxCxSpatial input tensor
target (torch.Tensor): NxCxSpatial target tensor
epsilon (float): prevents division by zero
weight (torch.Tensor): Cx1 tensor of weight per channel/class
"""
# input and target shapes must match
assert input.size() == target.size(), "'input' ({}) and 'target' ({}) must have the same shape".format(
input.size(), target.size())
input = flatten(input)
target = flatten(target)
target = target.float()
# compute per channel Dice Coefficient
intersect = (input * target).sum(-1)
if weight is not None:
intersect = weight * intersect
# here we can use standard dice (input + target).sum(-1) or extension (see V-Net) (input^2 + target^2).sum(-1)
denominator = (input * input).sum(-1) + (target * target).sum(-1)
return 2 * (intersect / denominator.clamp(min=epsilon))
def flatten(tensor):
"""Flattens a given tensor such that the channel axis is first.
The shapes are transformed as follows:
(N, C, D, H, W) -> (C, N * D * H * W)
"""
# number of channels
C = tensor.size(1)
# new axis order
axis_order = (1, 0) + tuple(range(2, tensor.dim()))
# Transpose: (N, C, D, H, W) -> (C, N, D, H, W)
transposed = tensor.permute(axis_order)
# Flatten: (C, N, D, H, W) -> (C, N * D * H * W)
return transposed.contiguous().view(C, -1)
| 1,799 | 38.130435 | 116 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/predict/utils.py | import numpy as np
def pytorch_predict_batch_array(model, batch, n_gpus=1):
import torch
batch_x = torch.tensor(np.moveaxis(np.asarray(batch), -1, 1)).float()
pred_x = pytorch_predict_batch(batch_x, model, n_gpus)
return np.moveaxis(pred_x.numpy(), 1, -1)
def get_feature_filename_and_subject_id(dataset, idx, verbose=False):
epoch_filenames = dataset.epoch_filenames[idx]
x_filename = epoch_filenames[dataset.feature_index]
if verbose:
print("Reading:", x_filename)
subject_id = epoch_filenames[-1]
return x_filename, subject_id
def pytorch_predict_batch(batch_x, model, n_gpus):
if n_gpus > 0:
batch_x = batch_x.cuda()
if hasattr(model, "test"):
pred_x = model.test(batch_x)
else:
pred_x = model(batch_x)
return pred_x.cpu() | 816 | 29.259259 | 73 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/predict/volumetric.py | import os
import numpy as np
from nilearn.image import new_img_like, resample_to_img
from unet3d.predict.utils import pytorch_predict_batch_array, get_feature_filename_and_subject_id
from unet3d.utils.utils import one_hot_image_to_label_map, get_nibabel_data
def load_volumetric_model(model_name, model_filename, n_outputs, n_features, n_gpus, strict, **kwargs):
from unet3d.models.pytorch.build import build_or_load_model
model = build_or_load_model(model_name=model_name, model_filename=model_filename, n_outputs=n_outputs,
n_features=n_features, n_gpus=n_gpus, strict=strict, **kwargs)
model.eval()
return model
def load_volumetric_sequence(sequence, sequence_kwargs, filenames, window, spacing, metric_names, batch_size=1):
from ..utils.pytorch.dataset import AEDataset
if sequence is None:
sequence = AEDataset
if sequence_kwargs is None:
sequence_kwargs = dict()
dataset = sequence(filenames=filenames, window=window, spacing=spacing, batch_size=batch_size,
metric_names=metric_names,
**sequence_kwargs)
return dataset
def load_volumetric_model_and_dataset(model_name, model_filename, model_kwargs, n_outputs, n_features,
strict_model_loading, n_gpus, sequence, sequence_kwargs, filenames, window,
spacing, metric_names):
if model_kwargs is None:
model_kwargs = dict()
model = load_volumetric_model(model_name=model_name, model_filename=model_filename, n_outputs=n_outputs,
n_features=n_features, strict=strict_model_loading, n_gpus=n_gpus, **model_kwargs)
dataset = load_volumetric_sequence(sequence, sequence_kwargs, filenames, window, spacing, metric_names,
batch_size=1)
basename = os.path.basename(model_filename).split(".")[0]
return model, dataset, basename
def load_images_from_dataset(dataset, idx, resample_predictions):
if resample_predictions:
x_image, ref_image = dataset.get_feature_image(idx, return_unmodified=True)
else:
x_image = dataset.get_feature_image(idx)
ref_image = None
return x_image, ref_image
def prediction_to_image(data, input_image, reference_image=None, interpolation="linear", segmentation=False,
segmentation_labels=None, threshold=0.5, sum_then_threshold=False, label_hierarchy=False):
if data.dtype == np.float16:
data = np.asarray(data, dtype=np.float32)
pred_image = new_img_like(input_image, data=data)
if reference_image is not None:
pred_image = resample_to_img(pred_image, reference_image,
interpolation=interpolation)
if segmentation:
pred_image = one_hot_image_to_label_map(pred_image,
labels=segmentation_labels,
threshold=threshold,
sum_then_threshold=sum_then_threshold,
label_hierarchy=label_hierarchy)
return pred_image
def write_prediction_image_to_file(pred_image, output_template, subject_id, x_filename, prediction_dir, basename,
verbose=False):
if output_template is None:
while type(x_filename) == list:
x_filename = x_filename[0]
pred_filename = os.path.join(prediction_dir,
"_".join([subject_id,
basename,
os.path.basename(x_filename)]))
else:
pred_filename = os.path.join(prediction_dir,
output_template.format(subject=subject_id))
if verbose:
print("Writing:", pred_filename)
pred_image.to_filename(pred_filename)
def predict_volumetric_batch(model, batch, batch_references, batch_subjects, batch_filenames,
basename, prediction_dir,
segmentation, output_template, n_gpus, verbose, threshold, interpolation,
segmentation_labels, sum_then_threshold, label_hierarchy, write_input_image=False):
pred_x = pytorch_predict_batch_array(model, batch, n_gpus=n_gpus)
for batch_idx in range(len(batch)):
pred_image = prediction_to_image(pred_x[batch_idx].squeeze(), input_image=batch_references[batch_idx][0],
reference_image=batch_references[batch_idx][1], interpolation=interpolation,
segmentation=segmentation, segmentation_labels=segmentation_labels,
threshold=threshold, sum_then_threshold=sum_then_threshold,
label_hierarchy=label_hierarchy)
write_prediction_image_to_file(pred_image, output_template,
subject_id=batch_subjects[batch_idx],
x_filename=batch_filenames[batch_idx],
prediction_dir=prediction_dir,
basename=basename,
verbose=verbose)
if write_input_image:
write_prediction_image_to_file(batch_references[batch_idx][0], output_template=output_template,
subject_id=batch_subjects[batch_idx] + "_input",
x_filename=batch_filenames[batch_idx],
prediction_dir=prediction_dir,
basename=basename,
verbose=verbose)
def pytorch_volumetric_predictions(model_filename, model_name, n_features, filenames, window,
criterion_name, prediction_dir=None, output_csv=None, reference=None,
n_gpus=1, n_workers=1, batch_size=1, model_kwargs=None, n_outputs=None,
sequence_kwargs=None, spacing=None, sequence=None,
strict_model_loading=True, metric_names=None,
print_prediction_time=True, verbose=True,
evaluate_predictions=False, resample_predictions=False, interpolation="linear",
output_template=None, segmentation=False, segmentation_labels=None,
sum_then_threshold=True, threshold=0.7, label_hierarchy=None,
write_input_images=False):
import torch
# from .train.pytorch import load_criterion
model, dataset, basename = load_volumetric_model_and_dataset(model_name, model_filename, model_kwargs, n_outputs,
n_features, strict_model_loading, n_gpus, sequence,
sequence_kwargs, filenames, window, spacing,
metric_names)
# criterion = load_criterion(criterion_name, n_gpus=n_gpus)
results = list()
print("Dataset: ", len(dataset))
with torch.no_grad():
batch = list()
batch_references = list()
batch_subjects = list()
batch_filenames = list()
for idx in range(len(dataset)):
x_filename, subject_id = get_feature_filename_and_subject_id(dataset, idx, verbose=verbose)
x_image, ref_image = load_images_from_dataset(dataset, idx, resample_predictions)
batch.append(get_nibabel_data(x_image))
batch_references.append((x_image, ref_image))
batch_subjects.append(subject_id)
batch_filenames.append(x_filename)
if len(batch) >= batch_size or idx == (len(dataset) - 1):
predict_volumetric_batch(model=model, batch=batch, batch_references=batch_references,
batch_subjects=batch_subjects, batch_filenames=batch_filenames,
basename=basename, prediction_dir=prediction_dir,
segmentation=segmentation, output_template=output_template, n_gpus=n_gpus,
verbose=verbose, threshold=threshold, interpolation=interpolation,
segmentation_labels=segmentation_labels,
sum_then_threshold=sum_then_threshold, label_hierarchy=label_hierarchy,
write_input_image=write_input_images)
batch = list()
batch_references = list()
batch_subjects = list()
batch_filenames = list()
def volumetric_predictions(model_filename, filenames, prediction_dir, model_name, n_features, window,
criterion_name, package="keras", n_gpus=1, n_workers=1, batch_size=1,
model_kwargs=None, n_outputs=None, sequence_kwargs=None, sequence=None,
metric_names=None, evaluate_predictions=False, interpolation="linear",
resample_predictions=True, output_template=None, segmentation=False,
segmentation_labels=None, threshold=0.5, sum_then_threshold=True, label_hierarchy=None,
write_input_images=False):
if package == "pytorch":
pytorch_volumetric_predictions(model_filename=model_filename,
model_name=model_name,
n_outputs=n_outputs,
n_features=n_features,
filenames=filenames,
prediction_dir=prediction_dir,
window=window,
criterion_name=criterion_name,
n_gpus=n_gpus,
n_workers=n_workers,
batch_size=batch_size,
model_kwargs=model_kwargs,
sequence_kwargs=sequence_kwargs,
sequence=sequence,
metric_names=metric_names,
evaluate_predictions=evaluate_predictions,
interpolation=interpolation,
resample_predictions=resample_predictions,
output_template=output_template,
segmentation=segmentation,
segmentation_labels=segmentation_labels,
threshold=threshold,
sum_then_threshold=sum_then_threshold,
label_hierarchy=label_hierarchy,
write_input_images=write_input_images)
else:
raise ValueError("Predictions not yet implemented for {}".format(package)) | 11,525 | 58.107692 | 117 | py |
3DUnetCNN | 3DUnetCNN-master/unet3d/predict/predict.py | import os
import numpy as np
import nibabel as nib
import pandas as pd
from nilearn.image import new_img_like
from unet3d.predict.volumetric import load_volumetric_model_and_dataset, load_images_from_dataset, \
prediction_to_image, write_prediction_image_to_file
from unet3d.predict.utils import pytorch_predict_batch_array, get_feature_filename_and_subject_id, pytorch_predict_batch
from unet3d.utils.utils import (load_json, get_nibabel_data, break_down_volume_into_half_size_volumes, combine_half_size_volumes)
from unet3d.utils.sequences import SubjectPredictionSequence
from unet3d.utils.pytorch.dataset import HCPSubjectDataset
from unet3d.utils.hcp import new_cifti_scalar_like, get_metric_data
from unet3d.utils.filenames import generate_hcp_filenames, load_subject_ids
from unet3d.utils.augment import generate_permutation_keys, permute_data, reverse_permute_data
def predict_data_loader(model, data_loader):
import torch
predictions = list()
with torch.no_grad():
for batch_x in data_loader:
predictions.extend(model(batch_x).cpu().numpy())
return np.asarray(predictions)
def predict_generator(model, generator, use_multiprocessing=False, n_workers=1, max_queue_size=8, verbose=1,
package="keras", batch_size=1):
if package == "pytorch":
from torch.utils.data import DataLoader
loader = DataLoader(generator, batch_size=batch_size, shuffle=False, num_workers=n_workers)
if verbose:
print("Loader: ", len(loader), " Batch_size: ", batch_size, " Dataset: ", len(generator))
return predict_data_loader(model, loader)
else:
return model.predict_generator(generator, use_multiprocessing=use_multiprocessing, workers=n_workers,
max_queue_size=max_queue_size, verbose=verbose)
def predict_subject(model, feature_filename, surface_filenames, surface_names, metric_names, output_filename,
reference_filename, batch_size=50, window=(64, 64, 64), flip=False, spacing=(1, 1, 1),
use_multiprocessing=False, workers=1, max_queue_size=10, overwrite=True,
generator=SubjectPredictionSequence, package="keras"):
if overwrite or not os.path.exists(output_filename):
generator = generator(feature_filename=feature_filename, surface_filenames=surface_filenames,
surface_names=surface_names, batch_size=batch_size, window=window, flip=flip,
spacing=spacing, reference_metric_filename=reference_filename)
prediction = predict_generator(model, generator, use_multiprocessing=use_multiprocessing, n_workers=workers,
max_queue_size=max_queue_size, verbose=1, batch_size=batch_size,
package=package)
output_image = new_cifti_scalar_like(np.moveaxis(prediction, 1, 0), scalar_names=metric_names,
structure_names=surface_names,
reference_cifti=nib.load(reference_filename), almost_equals_decimals=0)
output_image.to_filename(output_filename)
def make_predictions(config_filename, model_filename, output_directory='./', n_subjects=None, shuffle=False,
key='validation_filenames', use_multiprocessing=False, n_workers=1, max_queue_size=5,
batch_size=50, overwrite=True, single_subject=None, output_task_name=None, package="keras",
directory="./", n_gpus=1):
output_directory = os.path.abspath(output_directory)
config = load_json(config_filename)
if key not in config:
name = key.split("_")[0]
if name not in config:
load_subject_ids(config)
config[key] = generate_hcp_filenames(directory,
config['surface_basename_template'],
config['target_basenames'],
config['feature_basenames'],
config[name],
config['hemispheres'])
filenames = config[key]
model_basename = os.path.basename(model_filename).replace(".h5", "")
if "package" in config and config["package"] == "pytorch":
generator = HCPSubjectDataset
package = "pytorch"
else:
generator = SubjectPredictionSequence
if "model_kwargs" in config:
model_kwargs = config["model_kwargs"]
else:
model_kwargs = dict()
if "batch_size" in config:
batch_size = config["batch_size"]
if single_subject is None:
if package == "pytorch":
from unet3d.models.pytorch.build import build_or_load_model
model = build_or_load_model(model_filename=model_filename, model_name=config["model_name"],
n_features=config["n_features"], n_outputs=config["n_outputs"],
n_gpus=n_gpus, **model_kwargs)
else:
from keras.models import load_model
model = load_model(model_filename)
else:
model = None
if n_subjects is not None:
if shuffle:
np.random.shuffle(filenames)
filenames = filenames[:n_subjects]
for feature_filename, surface_filenames, metric_filenames, subject_id in filenames:
if single_subject is None or subject_id == single_subject:
if model is None:
if package == "pytorch":
from unet3d.models.pytorch.build import build_or_load_model
model = build_or_load_model(model_filename=model_filename, model_name=config["model_name"],
n_features=config["n_features"], n_outputs=config["n_outputs"],
n_gpus=n_gpus, **model_kwargs)
else:
model = load_model(model_filename)
if output_task_name is None:
_output_task_name = os.path.basename(metric_filenames[0]).split(".")[0]
if len(metric_filenames) > 1:
_output_task_name = "_".join(
_output_task_name.split("_")[:2] + ["ALL47"] + _output_task_name.split("_")[3:])
else:
_output_task_name = output_task_name
output_basename = "{task}-{model}_prediction.dscalar.nii".format(model=model_basename,
task=_output_task_name)
output_filename = os.path.join(output_directory, output_basename)
subject_metric_names = list()
for metric_list in config["metric_names"]:
for metric_name in metric_list:
subject_metric_names.append(metric_name.format(subject_id))
predict_subject(model,
feature_filename,
surface_filenames,
config['surface_names'],
subject_metric_names,
output_filename=output_filename,
batch_size=batch_size,
window=np.asarray(config['window']),
spacing=np.asarray(config['spacing']),
flip=False,
overwrite=overwrite,
use_multiprocessing=use_multiprocessing,
workers=n_workers,
max_queue_size=max_queue_size,
reference_filename=metric_filenames[0],
package=package,
generator=generator)
def predict_local_subject(model, feature_filename, surface_filename, batch_size=50, window=(64, 64, 64),
spacing=(1, 1, 1), flip=False, use_multiprocessing=False, workers=1, max_queue_size=10, ):
generator = SubjectPredictionSequence(feature_filename=feature_filename, surface_filename=surface_filename,
surface_name=None, batch_size=batch_size, window=window,
flip=flip, spacing=spacing)
return model.predict_generator(generator, use_multiprocessing=use_multiprocessing, workers=workers,
max_queue_size=max_queue_size, verbose=1)
def whole_brain_scalar_predictions(model_filename, subject_ids, hcp_dir, output_dir, hemispheres, feature_basenames,
surface_basename_template, target_basenames, model_name, n_outputs, n_features,
window, criterion_name, metric_names, surface_names, reference, package="keras",
n_gpus=1, n_workers=1, batch_size=1, model_kwargs=None):
from .scripts.train import generate_hcp_filenames
filenames = generate_hcp_filenames(directory=hcp_dir, surface_basename_template=surface_basename_template,
target_basenames=target_basenames, feature_basenames=feature_basenames,
subject_ids=subject_ids, hemispheres=hemispheres)
if package == "pytorch":
pytorch_whole_brain_scalar_predictions(model_filename=model_filename,
model_name=model_name,
n_outputs=n_outputs,
n_features=n_features,
filenames=filenames,
prediction_dir=output_dir,
window=window,
criterion_name=criterion_name,
metric_names=metric_names,
surface_names=surface_names,
reference=reference,
n_gpus=n_gpus,
n_workers=n_workers,
batch_size=batch_size,
model_kwargs=model_kwargs)
else:
raise ValueError("Predictions not yet implemented for {}".format(package))
def pytorch_whole_brain_scalar_predictions(model_filename, model_name, n_outputs, n_features, filenames, window,
criterion_name, metric_names, surface_names, prediction_dir=None,
output_csv=None, reference=None, n_gpus=1, n_workers=1, batch_size=1,
model_kwargs=None):
from .train.pytorch import load_criterion
from unet3d.models.pytorch.build import build_or_load_model
from .utils.pytorch.dataset import WholeBrainCIFTI2DenseScalarDataset
import torch
from torch.utils.data import DataLoader
if model_kwargs is None:
model_kwargs = dict()
model = build_or_load_model(model_name=model_name, model_filename=model_filename, n_outputs=n_outputs,
n_features=n_features, n_gpus=n_gpus, **model_kwargs)
model.eval()
basename = os.path.basename(model_filename).split(".")[0]
if prediction_dir and not output_csv:
output_csv = os.path.join(prediction_dir, str(basename) + "_prediction_scores.csv")
dataset = WholeBrainCIFTI2DenseScalarDataset(filenames=filenames,
window=window,
metric_names=metric_names,
surface_names=surface_names,
spacing=None,
batch_size=1)
criterion = load_criterion(criterion_name, n_gpus=n_gpus)
loader = DataLoader(dataset, batch_size=batch_size, shuffle=False, num_workers=n_workers)
results = list()
print("Loader: ", len(loader), " Batch_size: ", batch_size, " Dataset: ", len(dataset))
with torch.no_grad():
if reference is not None:
reference = torch.from_numpy(reference).unsqueeze(0)
if n_gpus > 0:
reference = reference.cuda()
for batch_idx, (x, y) in enumerate(loader):
print("Batch: ", batch_idx)
if n_gpus > 0:
x = x.cuda()
y = y.cuda()
pred_y = model(x)
if type(pred_y) == tuple:
pred_y = pred_y[0] # This is a hack to ignore other outputs that are used only for training
for i in range(batch_size):
row = list()
idx = (batch_idx * batch_size) + i
print("i: ", i, " idx: ", idx)
if idx >= len(dataset):
break
args = dataset.filenames[idx]
subject_id = args[-1]
row.append(subject_id)
idx_score = criterion(pred_y[i].unsqueeze(0), y[i].unsqueeze(0)).item()
row.append(idx_score)
if reference is not None:
idx_ref_score = criterion(reference.reshape(y[i].unsqueeze(0).shape),
y[i].unsqueeze(0)).item()
row.append(idx_ref_score)
results.append(row)
save_predictions(prediction=pred_y[i].cpu().numpy(), args=args, basename=basename,
metric_names=metric_names, surface_names=surface_names, prediction_dir=prediction_dir)
if output_csv is not None:
columns = ["subject_id", criterion_name]
if reference is not None:
columns.append("reference_" + criterion_name)
pd.DataFrame(results, columns=columns).to_csv(output_csv)
def save_predictions(prediction, args, basename, metric_names, surface_names, prediction_dir):
ref_filename = args[2][0]
subject_id = args[-1]
ref_basename = os.path.basename(ref_filename)
prediction_name = "_".join((subject_id, basename, "prediction"))
_metric_names = [_metric_name.format(prediction_name) for _metric_name in np.asarray(metric_names).ravel()]
output_filename = os.path.join(prediction_dir, ref_basename.replace(subject_id, prediction_name))
if prediction_dir is not None and not os.path.exists(output_filename):
ref_cifti = nib.load(ref_filename)
prediction_array = prediction.reshape(len(_metric_names),
np.sum(ref_cifti.header.get_axis(1).surface_mask))
cifti_file = new_cifti_scalar_like(prediction_array, _metric_names, surface_names, ref_cifti)
cifti_file.to_filename(output_filename)
def pytorch_subject_predictions(idx, model, dataset, criterion, basename, prediction_dir, surface_names, metric_names,
n_gpus, reference):
import torch
with torch.no_grad():
args = dataset.filenames[idx]
ref_filename = args[2][0]
subject_id = args[-1]
ref_basename = os.path.basename(ref_filename)
prediction_name = "_".join((subject_id, basename, "prediction"))
_metric_names = [_metric_name.format(prediction_name) for _metric_name in np.asarray(metric_names).ravel()]
output_filename = os.path.join(prediction_dir, ref_basename.replace(subject_id, prediction_name))
x, y = dataset[idx]
if os.path.exists(output_filename):
prediction = torch.from_numpy(get_metric_data([nib.load(output_filename)],
[_metric_names],
surface_names,
subject_id)).float().cpu()
else:
prediction = model(x.unsqueeze(0))
if n_gpus > 0:
prediction = prediction.cpu()
y = y.unsqueeze(0)
score = criterion(prediction.reshape(y.shape), y).item()
row = [subject_id, score]
if reference is not None:
reference_score = criterion(reference.reshape(y.shape), y).item()
row.append(reference_score)
if prediction_dir is not None and not os.path.exists(output_filename):
ref_cifti = nib.load(ref_filename)
prediction_array = prediction.numpy().reshape(len(_metric_names),
np.sum(ref_cifti.header.get_axis(1).surface_mask))
cifti_file = new_cifti_scalar_like(prediction_array, _metric_names, surface_names, ref_cifti)
cifti_file.to_filename(output_filename)
return row
def single_volume_zstat_denoising(model_filename, model_name, n_features, filenames, window, prediction_dir,
n_gpus=1, batch_size=1, model_kwargs=None, n_outputs=None,
sequence_kwargs=None, spacing=None, sequence=None,
strict_model_loading=True, metric_names=None,
verbose=True, resample_predictions=False, **unused_kwargs):
import torch
model, dataset, basename = load_volumetric_model_and_dataset(model_name, model_filename, model_kwargs, n_outputs,
n_features, strict_model_loading, n_gpus, sequence,
sequence_kwargs, filenames, window, spacing,
metric_names)
dataset.extract_sub_volumes = False
print("Dataset: ", len(dataset))
with torch.no_grad():
completed = set()
batch = list()
for idx in range(len(dataset)):
x_filename, subject_id = get_feature_filename_and_subject_id(dataset, idx, verbose=False)
while type(x_filename) == list:
x_filename = x_filename[0]
if x_filename in completed:
continue
if verbose:
print("Reading:", x_filename)
x_image, ref_image = load_images_from_dataset(dataset, idx, resample_predictions)
if len(x_image.shape) == 4:
volumes_per_image = x_image.shape[3]
prediction_data = np.zeros(x_image.shape)
else:
volumes_per_image = 1
prediction_data = np.zeros(x_image.shape + (volumes_per_image,))
data = get_nibabel_data(x_image)
for image_idx in range(volumes_per_image):
batch.append(data[..., image_idx][..., None])
if len(batch) >= batch_size or image_idx == volumes_per_image - 1:
prediction = pytorch_predict_batch_array(model, batch, n_gpus)
prediction = np.moveaxis(prediction, 0, -1).squeeze()
prediction_data[..., (image_idx - prediction.shape[-1] + 1):(image_idx + 1)] = prediction
batch = list()
pred_image = new_img_like(ref_niimg=x_image, data=prediction_data)
output_filename = os.path.join(prediction_dir, "_".join((subject_id,
basename,
os.path.basename(x_filename))))
if verbose:
print("Writing:", output_filename)
pred_image.to_filename(output_filename)
completed.add(x_filename)
def predictions_with_permutations(model_filename, model_name, n_features, filenames, window, prediction_dir=None,
n_gpus=1, batch_size=1, model_kwargs=None, n_outputs=None, sequence_kwargs=None,
spacing=None, sequence=None, strict_model_loading=True, metric_names=None,
verbose=True, resample_predictions=False, interpolation="linear",
output_template=None, segmentation=False, segmentation_labels=None,
sum_then_threshold=True, threshold=0.5, label_hierarchy=None, permutation_weight=None,
**unused_args):
import torch
model, dataset, basename = load_volumetric_model_and_dataset(model_name, model_filename, model_kwargs, n_outputs,
n_features, strict_model_loading, n_gpus, sequence,
sequence_kwargs, filenames, window, spacing,
metric_names)
permutation_keys = list(generate_permutation_keys())
permutation_weights = np.ones((len(permutation_keys), 1, 1, 1, 1))
# TODO: make this work with models that only output one prediction map
if permutation_weight is not None:
non_perm_index = permutation_keys.index(((0, 0), 0, 0, 0, 0))
permutation_weights = permutation_weights * permutation_weight
permutation_weights[non_perm_index] = len(permutation_keys) * (1 - permutation_weight)
dataset.extract_sub_volumes = False
print("Dataset: ", len(dataset))
with torch.no_grad():
for idx in range(len(dataset)):
x_filename, subject_id = get_feature_filename_and_subject_id(dataset, idx, verbose=verbose)
x_image, ref_image = load_images_from_dataset(dataset, idx, resample_predictions)
data = get_nibabel_data(x_image)
prediction_data = predict_with_permutations(model, data, n_outputs, batch_size, n_gpus, permutation_keys,
permutation_weights)
pred_image = prediction_to_image(prediction_data.squeeze(),
input_image=x_image,
reference_image=ref_image,
interpolation=interpolation,
segmentation=segmentation,
segmentation_labels=segmentation_labels,
threshold=threshold,
sum_then_threshold=sum_then_threshold,
label_hierarchy=label_hierarchy)
write_prediction_image_to_file(pred_image,
output_template,
subject_id=subject_id,
x_filename=x_filename,
prediction_dir=prediction_dir,
basename=basename,
verbose=verbose)
def predict_with_permutations(model, data, n_outputs, batch_size, n_gpus, permutation_keys, permutation_weights):
import torch
prediction_data = np.zeros((len(permutation_keys),) + data.shape[:3] + (n_outputs,))
batch = list()
permutation_indices = list()
data = np.moveaxis(data, 3, 0)
for permutation_idx, permutation_key in enumerate(permutation_keys):
batch.append(permute_data(data, permutation_key))
permutation_indices.append(permutation_idx)
if len(batch) >= batch_size or permutation_key == permutation_keys[-1]:
batch_prediction = pytorch_predict_batch(torch.tensor(batch).float(), model, n_gpus).numpy()
for batch_idx, perm_idx in enumerate(permutation_indices):
prediction_data[perm_idx] = np.moveaxis(reverse_permute_data(batch_prediction[batch_idx],
permutation_keys[perm_idx]).squeeze(),
0, 3)
batch = list()
permutation_indices = list()
# average over all the permutations
return np.mean(prediction_data * permutation_weights, axis=0)
def predict_super_resolution(model_filename, model_name, n_features, filenames, window, prediction_dir=None,
n_gpus=1, batch_size=1, model_kwargs=None, n_outputs=None, sequence_kwargs=None,
spacing=None, sequence=None, strict_model_loading=True, metric_names=None,
verbose=True, resample_predictions=False, interpolation="linear",
output_template=None, segmentation=False, segmentation_labels=None,
sum_then_threshold=True, threshold=0.5, label_hierarchy=None, **unused_args):
import torch
new_window = list(np.asarray(window) * 2)
model, dataset, basename = load_volumetric_model_and_dataset(model_name, model_filename, model_kwargs, n_outputs,
n_features, strict_model_loading, n_gpus, sequence,
sequence_kwargs, filenames, new_window, spacing,
metric_names)
dataset.extract_sub_volumes = False
print("Dataset: ", len(dataset))
with torch.no_grad():
for idx in range(len(dataset)):
x_filename, subject_id = get_feature_filename_and_subject_id(dataset, idx, verbose=verbose)
x_image, ref_image = load_images_from_dataset(dataset, idx, resample_predictions)
data = get_nibabel_data(x_image)
prediction_data = predict_super_resolution_data(model, data, batch_size, n_gpus)
pred_image = prediction_to_image(prediction_data.squeeze(),
input_image=x_image,
reference_image=ref_image,
interpolation=interpolation,
segmentation=segmentation,
segmentation_labels=segmentation_labels,
threshold=threshold,
sum_then_threshold=sum_then_threshold,
label_hierarchy=label_hierarchy)
write_prediction_image_to_file(pred_image,
output_template,
subject_id=subject_id,
x_filename=x_filename,
prediction_dir=prediction_dir,
basename=basename,
verbose=verbose)
def predict_super_resolution_data(model, data, batch_size, n_gpus):
batch = list()
input_data = break_down_volume_into_half_size_volumes(data)
predicted_data = list()
for i, volume in enumerate(input_data):
batch.append(volume)
if len(batch) >= batch_size or i == (len(input_data) - 1):
batch_prediction = pytorch_predict_batch_array(model=model, batch=batch, n_gpus=n_gpus)
for batch_idx in range(batch_prediction.shape[0]):
predicted_data.append(batch_prediction[batch_idx])
batch = list()
return combine_half_size_volumes(predicted_data)
| 27,747 | 56.808333 | 129 | py |
3DUnetCNN | 3DUnetCNN-master/legacy/unet3dlegacy/training.py | import math
from functools import partial
from keras import backend as K
from keras.callbacks import ModelCheckpoint, CSVLogger, LearningRateScheduler, ReduceLROnPlateau, EarlyStopping
from keras.models import load_model
from unet3d.metrics import (dice_coefficient, dice_coefficient_loss, dice_coef, dice_coef_loss,
weighted_dice_coefficient_loss, weighted_dice_coefficient)
K.set_image_data_format('channels_first')
# learning rate schedule
def step_decay(epoch, initial_lrate, drop, epochs_drop):
return initial_lrate * math.pow(drop, math.floor((1+epoch)/float(epochs_drop)))
def get_callbacks(model_file, initial_learning_rate=0.0001, learning_rate_drop=0.5, learning_rate_epochs=None,
learning_rate_patience=50, logging_file="training.log", verbosity=1,
early_stopping_patience=None):
callbacks = list()
callbacks.append(ModelCheckpoint(model_file, save_best_only=True))
callbacks.append(CSVLogger(logging_file, append=True))
if learning_rate_epochs:
callbacks.append(LearningRateScheduler(partial(step_decay, initial_lrate=initial_learning_rate,
drop=learning_rate_drop, epochs_drop=learning_rate_epochs)))
else:
callbacks.append(ReduceLROnPlateau(factor=learning_rate_drop, patience=learning_rate_patience,
verbose=verbosity))
if early_stopping_patience:
callbacks.append(EarlyStopping(verbose=verbosity, patience=early_stopping_patience))
return callbacks
def load_old_model(model_file):
print("Loading pre-trained model")
custom_objects = {'dice_coefficient_loss': dice_coefficient_loss, 'dice_coefficient': dice_coefficient,
'dice_coef': dice_coef, 'dice_coef_loss': dice_coef_loss,
'weighted_dice_coefficient': weighted_dice_coefficient,
'weighted_dice_coefficient_loss': weighted_dice_coefficient_loss}
try:
from keras_contrib.layers import InstanceNormalization
custom_objects["InstanceNormalization"] = InstanceNormalization
except ImportError:
pass
try:
return load_model(model_file, custom_objects=custom_objects)
except ValueError as error:
if 'InstanceNormalization' in str(error):
raise ValueError(str(error) + "\n\nPlease install keras-contrib to use InstanceNormalization:\n"
"'pip install git+https://www.github.com/keras-team/keras-contrib.git'")
else:
raise error
def train_model(model, model_file, training_generator, validation_generator, steps_per_epoch, validation_steps,
initial_learning_rate=0.001, learning_rate_drop=0.5, learning_rate_epochs=None, n_epochs=500,
learning_rate_patience=20, early_stopping_patience=None):
"""
Train a Keras model.
:param early_stopping_patience: If set, training will end early if the validation loss does not improve after the
specified number of epochs.
:param learning_rate_patience: If learning_rate_epochs is not set, the learning rate will decrease if the validation
loss does not improve after the specified number of epochs. (default is 20)
:param model: Keras model that will be trained.
:param model_file: Where to save the Keras model.
:param training_generator: Generator that iterates through the training data.
:param validation_generator: Generator that iterates through the validation data.
:param steps_per_epoch: Number of batches that the training generator will provide during a given epoch.
:param validation_steps: Number of batches that the validation generator will provide during a given epoch.
:param initial_learning_rate: Learning rate at the beginning of training.
:param learning_rate_drop: How much at which to the learning rate will decay.
:param learning_rate_epochs: Number of epochs after which the learning rate will drop.
:param n_epochs: Total number of epochs to train the model.
:return:
"""
model.fit_generator(generator=training_generator,
steps_per_epoch=steps_per_epoch,
epochs=n_epochs,
validation_data=validation_generator,
validation_steps=validation_steps,
callbacks=get_callbacks(model_file,
initial_learning_rate=initial_learning_rate,
learning_rate_drop=learning_rate_drop,
learning_rate_epochs=learning_rate_epochs,
learning_rate_patience=learning_rate_patience,
early_stopping_patience=early_stopping_patience))
| 4,931 | 54.41573 | 120 | py |
3DUnetCNN | 3DUnetCNN-master/legacy/unet3dlegacy/metrics.py | from functools import partial
from keras import backend as K
def dice_coefficient(y_true, y_pred, smooth=1.):
y_true_f = K.flatten(y_true)
y_pred_f = K.flatten(y_pred)
intersection = K.sum(y_true_f * y_pred_f)
return (2. * intersection + smooth) / (K.sum(y_true_f) + K.sum(y_pred_f) + smooth)
def dice_coefficient_loss(y_true, y_pred):
return -dice_coefficient(y_true, y_pred)
def weighted_dice_coefficient(y_true, y_pred, axis=(-3, -2, -1), smooth=0.00001):
"""
Weighted dice coefficient. Default axis assumes a "channels first" data structure
:param smooth:
:param y_true:
:param y_pred:
:param axis:
:return:
"""
return K.mean(2. * (K.sum(y_true * y_pred,
axis=axis) + smooth/2)/(K.sum(y_true,
axis=axis) + K.sum(y_pred,
axis=axis) + smooth))
def weighted_dice_coefficient_loss(y_true, y_pred):
return -weighted_dice_coefficient(y_true, y_pred)
def label_wise_dice_coefficient(y_true, y_pred, label_index):
return dice_coefficient(y_true[:, label_index], y_pred[:, label_index])
def get_label_dice_coefficient_function(label_index):
f = partial(label_wise_dice_coefficient, label_index=label_index)
f.__setattr__('__name__', 'label_{0}_dice_coef'.format(label_index))
return f
dice_coef = dice_coefficient
dice_coef_loss = dice_coefficient_loss
| 1,508 | 30.4375 | 100 | py |
3DUnetCNN | 3DUnetCNN-master/legacy/unet3dlegacy/model/isensee2017.py | from functools import partial
from keras.layers import Input, LeakyReLU, Add, UpSampling3D, Activation, SpatialDropout3D, Conv3D
from keras.engine import Model
from keras.optimizers import Adam
from .unet import create_convolution_block, concatenate
from ..metrics import weighted_dice_coefficient_loss
create_convolution_block = partial(create_convolution_block, activation=LeakyReLU, instance_normalization=True)
def isensee2017_model(input_shape=(4, 128, 128, 128), n_base_filters=16, depth=5, dropout_rate=0.3,
n_segmentation_levels=3, n_labels=4, optimizer=Adam, initial_learning_rate=5e-4,
loss_function=weighted_dice_coefficient_loss, activation_name="sigmoid"):
"""
This function builds a model proposed by Isensee et al. for the BRATS 2017 competition:
https://www.cbica.upenn.edu/sbia/Spyridon.Bakas/MICCAI_BraTS/MICCAI_BraTS_2017_proceedings_shortPapers.pdf
This network is highly similar to the model proposed by Kayalibay et al. "CNN-based Segmentation of Medical
Imaging Data", 2017: https://arxiv.org/pdf/1701.03056.pdf
:param input_shape:
:param n_base_filters:
:param depth:
:param dropout_rate:
:param n_segmentation_levels:
:param n_labels:
:param optimizer:
:param initial_learning_rate:
:param loss_function:
:param activation_name:
:return:
"""
inputs = Input(input_shape)
current_layer = inputs
level_output_layers = list()
level_filters = list()
for level_number in range(depth):
n_level_filters = (2**level_number) * n_base_filters
level_filters.append(n_level_filters)
if current_layer is inputs:
in_conv = create_convolution_block(current_layer, n_level_filters)
else:
in_conv = create_convolution_block(current_layer, n_level_filters, strides=(2, 2, 2))
context_output_layer = create_context_module(in_conv, n_level_filters, dropout_rate=dropout_rate)
summation_layer = Add()([in_conv, context_output_layer])
level_output_layers.append(summation_layer)
current_layer = summation_layer
segmentation_layers = list()
for level_number in range(depth - 2, -1, -1):
up_sampling = create_up_sampling_module(current_layer, level_filters[level_number])
concatenation_layer = concatenate([level_output_layers[level_number], up_sampling], axis=1)
localization_output = create_localization_module(concatenation_layer, level_filters[level_number])
current_layer = localization_output
if level_number < n_segmentation_levels:
segmentation_layers.insert(0, Conv3D(n_labels, (1, 1, 1))(current_layer))
output_layer = None
for level_number in reversed(range(n_segmentation_levels)):
segmentation_layer = segmentation_layers[level_number]
if output_layer is None:
output_layer = segmentation_layer
else:
output_layer = Add()([output_layer, segmentation_layer])
if level_number > 0:
output_layer = UpSampling3D(size=(2, 2, 2))(output_layer)
activation_block = Activation(activation_name)(output_layer)
model = Model(inputs=inputs, outputs=activation_block)
model.compile(optimizer=optimizer(lr=initial_learning_rate), loss=loss_function)
return model
def create_localization_module(input_layer, n_filters):
convolution1 = create_convolution_block(input_layer, n_filters)
convolution2 = create_convolution_block(convolution1, n_filters, kernel=(1, 1, 1))
return convolution2
def create_up_sampling_module(input_layer, n_filters, size=(2, 2, 2)):
up_sample = UpSampling3D(size=size)(input_layer)
convolution = create_convolution_block(up_sample, n_filters)
return convolution
def create_context_module(input_layer, n_level_filters, dropout_rate=0.3, data_format="channels_first"):
convolution1 = create_convolution_block(input_layer=input_layer, n_filters=n_level_filters)
dropout = SpatialDropout3D(rate=dropout_rate, data_format=data_format)(convolution1)
convolution2 = create_convolution_block(input_layer=dropout, n_filters=n_level_filters)
return convolution2
| 4,212 | 39.509615 | 111 | py |
3DUnetCNN | 3DUnetCNN-master/legacy/unet3dlegacy/model/unet.py | import numpy as np
from keras import backend as K
from keras.engine import Input, Model
from keras.layers import Conv3D, MaxPooling3D, UpSampling3D, Activation, BatchNormalization, PReLU, Deconvolution3D
from keras.optimizers import Adam
from unet3d.metrics import get_label_dice_coefficient_function, dice_coefficient, weighted_dice_coefficient_loss
K.set_image_data_format("channels_first")
try:
from keras.engine import merge
except ImportError:
from keras.layers.merge import concatenate
def unet_model_3d(input_shape, pool_size=(2, 2, 2), n_labels=1, initial_learning_rate=0.00001, deconvolution=False,
depth=4, n_base_filters=32, include_label_wise_dice_coefficients=False, metrics=dice_coefficient,
batch_normalization=False, activation_name="sigmoid"):
"""
Builds the 3D UNet Keras model.f
:param metrics: List metrics to be calculated during model training (default is dice coefficient).
:param include_label_wise_dice_coefficients: If True and n_labels is greater than 1, model will report the dice
coefficient for each label as metric.
:param n_base_filters: The number of filters that the first layer in the convolution network will have. Following
layers will contain a multiple of this number. Lowering this number will likely reduce the amount of memory required
to train the model.
:param depth: indicates the depth of the U-shape for the model. The greater the depth, the more max pooling
layers will be added to the model. Lowering the depth may reduce the amount of memory required for training.
:param input_shape: Shape of the input data (n_chanels, x_size, y_size, z_size). The x, y, and z sizes must be
divisible by the pool size to the power of the depth of the UNet, that is pool_size^depth.
:param pool_size: Pool size for the max pooling operations.
:param n_labels: Number of binary labels that the model is learning.
:param initial_learning_rate: Initial learning rate for the model. This will be decayed during training.
:param deconvolution: If set to True, will use transpose convolution(deconvolution) instead of up-sampling. This
increases the amount memory required during training.
:return: Untrained 3D UNet Model
"""
inputs = Input(input_shape)
current_layer = inputs
levels = list()
# add levels with max pooling
for layer_depth in range(depth):
layer1 = create_convolution_block(input_layer=current_layer, n_filters=n_base_filters*(2**layer_depth),
batch_normalization=batch_normalization)
layer2 = create_convolution_block(input_layer=layer1, n_filters=n_base_filters*(2**layer_depth)*2,
batch_normalization=batch_normalization)
if layer_depth < depth - 1:
current_layer = MaxPooling3D(pool_size=pool_size)(layer2)
levels.append([layer1, layer2, current_layer])
else:
current_layer = layer2
levels.append([layer1, layer2])
# add levels with up-convolution or up-sampling
for layer_depth in range(depth-2, -1, -1):
up_convolution = get_up_convolution(pool_size=pool_size, deconvolution=deconvolution,
n_filters=current_layer._keras_shape[1])(current_layer)
concat = concatenate([up_convolution, levels[layer_depth][1]], axis=1)
current_layer = create_convolution_block(n_filters=levels[layer_depth][1]._keras_shape[1],
input_layer=concat, batch_normalization=batch_normalization)
current_layer = create_convolution_block(n_filters=levels[layer_depth][1]._keras_shape[1],
input_layer=current_layer,
batch_normalization=batch_normalization)
final_convolution = Conv3D(n_labels, (1, 1, 1))(current_layer)
act = Activation(activation_name)(final_convolution)
model = Model(inputs=inputs, outputs=act)
if not isinstance(metrics, list):
metrics = [metrics]
if include_label_wise_dice_coefficients and n_labels > 1:
label_wise_dice_metrics = [get_label_dice_coefficient_function(index) for index in range(n_labels)]
if metrics:
metrics = metrics + label_wise_dice_metrics
else:
metrics = label_wise_dice_metrics
model.compile(optimizer=Adam(lr=initial_learning_rate), loss=weighted_dice_coefficient_loss, metrics=metrics)
return model
def create_convolution_block(input_layer, n_filters, batch_normalization=False, kernel=(3, 3, 3), activation=None,
padding='same', strides=(1, 1, 1), instance_normalization=False):
"""
:param strides:
:param input_layer:
:param n_filters:
:param batch_normalization:
:param kernel:
:param activation: Keras activation layer to use. (default is 'relu')
:param padding:
:return:
"""
layer = Conv3D(n_filters, kernel, padding=padding, strides=strides)(input_layer)
if batch_normalization:
layer = BatchNormalization(axis=1)(layer)
elif instance_normalization:
try:
from keras_contrib.layers import InstanceNormalization
except ImportError:
raise ImportError("Install keras_contrib in order to use instance normalization."
"\nTry: pip install git+https://www.github.com/farizrahman4u/keras-contrib.git")
layer = InstanceNormalization(axis=1)(layer)
if activation is None:
return Activation('relu')(layer)
else:
return activation()(layer)
def compute_level_output_shape(n_filters, depth, pool_size, image_shape):
"""
Each level has a particular output shape based on the number of filters used in that level and the depth or number
of max pooling operations that have been done on the data at that point.
:param image_shape: shape of the 3d image.
:param pool_size: the pool_size parameter used in the max pooling operation.
:param n_filters: Number of filters used by the last node in a given level.
:param depth: The number of levels down in the U-shaped model a given node is.
:return: 5D vector of the shape of the output node
"""
output_image_shape = np.asarray(np.divide(image_shape, np.power(pool_size, depth)), dtype=np.int32).tolist()
return tuple([None, n_filters] + output_image_shape)
def get_up_convolution(n_filters, pool_size, kernel_size=(2, 2, 2), strides=(2, 2, 2),
deconvolution=False):
if deconvolution:
return Deconvolution3D(filters=n_filters, kernel_size=kernel_size,
strides=strides)
else:
return UpSampling3D(size=pool_size)
| 6,865 | 49.859259 | 120 | py |
3DUnetCNN | 3DUnetCNN-master/legacy/test/test_training.py | from unittest import TestCase
from keras.callbacks import ReduceLROnPlateau, EarlyStopping
from unet3d.training import get_callbacks
class TestCallbakcs(TestCase):
def test_reduce_on_plateau(self):
_, _, scheduler = get_callbacks(model_file='model.h5', learning_rate_patience=50, learning_rate_drop=0.5)
self.assertIsInstance(scheduler, ReduceLROnPlateau)
def test_early_stopping(self):
_, _, _, stopper = get_callbacks(model_file='model.h5', early_stopping_patience=100)
self.assertIsInstance(stopper, EarlyStopping)
| 564 | 32.235294 | 113 | py |
3DUnetCNN | 3DUnetCNN-master/legacy/test/test_metrics.py | from unittest import TestCase
import numpy as np
import keras.backend as K
from unet3d.metrics import weighted_dice_coefficient
class TestWeightedDice(TestCase):
def test_weighted_dice_coefficient(self):
data = np.zeros((5**3) * 3).reshape(3, 5, 5, 5)
data[0, 0:1] = 1
data[1, 0:2] = 1
data[2, 1:4] = 1
max_dice = K.eval(weighted_dice_coefficient(K.variable(data), K.variable(data)))
for index in range(data.shape[0]):
temp_data = np.copy(data)
temp_data[index] = 0
dice = K.eval(weighted_dice_coefficient(K.variable(data), K.variable(temp_data)))
self.assertAlmostEqual(dice, (2 * max_dice)/3, delta=0.00001)
def test_blank_dice_coefficient(self):
data = np.zeros((5**3) * 3).reshape(3, 5, 5, 5)
blank = np.copy(data)
data[0, 0:1] = 1
data[1, 0:2] = 1
data[2, 1:4] = 1
self.assertAlmostEqual(K.eval(weighted_dice_coefficient(K.variable(data), K.variable(blank))), 0, delta=0.00001)
def test_empty_label(self):
data = np.zeros((5**3) * 3).reshape(3, 5, 5, 5)
data[1, 0:2] = 1
data[2, 1:4] = 1
self.assertEqual(K.eval(weighted_dice_coefficient(K.variable(data), K.variable(data))), 1)
| 1,282 | 31.897436 | 120 | py |
DiffPure | DiffPure-master/eval_sde_adv_bpda.py | # ---------------------------------------------------------------
# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# This work is licensed under the NVIDIA Source Code License
# for DiffPure. To view a copy of this license, see the LICENSE file.
# ---------------------------------------------------------------
import argparse
import logging
import yaml
import os
import time
import random
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from bpda_eot.bpda_eot_attack import BPDA_EOT_Attack
import utils
from utils import str2bool, get_accuracy, get_image_classifier, load_data
from runners.diffpure_ddpm import Diffusion
from runners.diffpure_guided import GuidedDiffusion
from runners.diffpure_sde import RevGuidedDiffusion
class ResNet_Adv_Model(nn.Module):
def __init__(self, args, config):
super().__init__()
# image classifier
self.resnet = get_image_classifier(args.classifier_name).to(config.device)
def purify(self, x):
return x
def forward(self, x, mode='purify_and_classify'):
if mode == 'purify':
out = self.purify(x)
elif mode == 'classify':
out = self.resnet(x) # x in [0, 1]
elif mode == 'purify_and_classify':
x = self.purify(x)
out = self.resnet(x) # x in [0, 1]
else:
raise NotImplementedError(f'unknown mode: {mode}')
return out
class SDE_Adv_Model(nn.Module):
def __init__(self, args, config):
super().__init__()
self.args = args
# image classifier
self.resnet = get_image_classifier(args.classifier_name).to(config.device)
# diffusion model
print(f'diffusion_type: {args.diffusion_type}')
if args.diffusion_type == 'ddpm':
self.runner = GuidedDiffusion(args, config, device=config.device)
elif args.diffusion_type == 'sde':
self.runner = RevGuidedDiffusion(args, config, device=config.device)
elif args.diffusion_type == 'celebahq-ddpm':
self.runner = Diffusion(args, config, device=config.device)
else:
raise NotImplementedError('unknown diffusion type')
self.register_buffer('counter', torch.zeros(1, device=config.device))
self.tag = None
# use `counter` to record the the sampling time every 5 NFEs (note we hardcoded print freq to 5,
# and you may want to change the freq)
def reset_counter(self):
self.counter = torch.zeros(1, dtype=torch.int, device=config.device)
def set_tag(self, tag=None):
self.tag = tag
def purify(self, x):
counter = self.counter.item()
if counter % 5 == 0:
print(f'diffusion times: {counter}')
# imagenet [3, 224, 224] -> [3, 256, 256] -> [3, 224, 224]
if 'imagenet' in self.args.domain:
x = F.interpolate(x, size=(256, 256), mode='bilinear', align_corners=False)
start_time = time.time()
x_re = self.runner.image_editing_sample((x - 0.5) * 2, bs_id=counter, tag=self.tag)
minutes, seconds = divmod(time.time() - start_time, 60)
if 'imagenet' in self.args.domain:
x_re = F.interpolate(x_re, size=(224, 224), mode='bilinear', align_corners=False)
if counter % 5 == 0:
print(f'x shape (before diffusion models): {x.shape}')
print(f'x shape (before resnet): {x_re.shape}')
print("Sampling time per batch: {:0>2}:{:05.2f}".format(int(minutes), seconds))
self.counter += 1
return (x_re + 1) * 0.5
def forward(self, x, mode='purify_and_classify'):
if mode == 'purify':
out = self.purify(x)
elif mode == 'classify':
out = self.resnet(x) # x in [0, 1]
elif mode == 'purify_and_classify':
x = self.purify(x)
out = self.resnet(x) # x in [0, 1]
else:
raise NotImplementedError(f'unknown mode: {mode}')
return out
def eval_bpda(args, config, model, x_val, y_val, adv_batch_size, log_dir):
ngpus = torch.cuda.device_count()
model_ = model
if ngpus > 1:
model_ = model.module
x_val, y_val = x_val.to(config.device), y_val.to(config.device)
# ------------------ apply the attack to resnet ------------------
print(f'apply the bpda attack to resnet...')
resnet_bpda = ResNet_Adv_Model(args, config)
if ngpus > 1:
resnet_bpda = torch.nn.DataParallel(resnet_bpda)
start_time = time.time()
init_acc = get_accuracy(resnet_bpda, x_val, y_val, bs=adv_batch_size)
print('initial accuracy: {:.2%}, time elapsed: {:.2f}s'.format(init_acc, time.time() - start_time))
adversary_resnet = BPDA_EOT_Attack(resnet_bpda, adv_eps=args.adv_eps, eot_defense_reps=args.eot_defense_reps,
eot_attack_reps=args.eot_attack_reps)
start_time = time.time()
class_batch, ims_adv_batch = adversary_resnet.attack_all(x_val, y_val, batch_size=adv_batch_size)
init_acc = float(class_batch[0, :].sum()) / class_batch.shape[1]
robust_acc = float(class_batch[-1, :].sum()) / class_batch.shape[1]
print('init acc: {:.2%}, robust acc: {:.2%}, time elapsed: {:.2f}s'.format(init_acc, robust_acc, time.time() - start_time))
print(f'x_adv_resnet shape: {ims_adv_batch.shape}')
torch.save([ims_adv_batch, y_val], f'{log_dir}/x_adv_resnet_sd{args.seed}.pt')
# ------------------ apply the attack to sde_adv ------------------
print(f'apply the bpda attack to sde_adv...')
start_time = time.time()
model_.reset_counter()
model_.set_tag('no_adv')
init_acc = get_accuracy(model, x_val, y_val, bs=adv_batch_size)
print('initial accuracy: {:.2%}, time elapsed: {:.2f}s'.format(init_acc, time.time() - start_time))
adversary_sde = BPDA_EOT_Attack(model, adv_eps=args.adv_eps, eot_defense_reps=args.eot_defense_reps,
eot_attack_reps=args.eot_attack_reps)
start_time = time.time()
model_.reset_counter()
model_.set_tag()
class_batch, ims_adv_batch = adversary_sde.attack_all(x_val, y_val, batch_size=adv_batch_size)
init_acc = float(class_batch[0, :].sum()) / class_batch.shape[1]
robust_acc = float(class_batch[-1, :].sum()) / class_batch.shape[1]
print('init acc: {:.2%}, robust acc: {:.2%}, time elapsed: {:.2f}s'.format(init_acc, robust_acc, time.time() - start_time))
print(f'x_adv_sde shape: {ims_adv_batch.shape}')
torch.save([ims_adv_batch, y_val], f'{log_dir}/x_adv_sde_sd{args.seed}.pt')
def robustness_eval(args, config):
middle_name = '_'.join([args.diffusion_type, 'bpda'])
log_dir = os.path.join(args.image_folder, args.classifier_name, middle_name,
'seed' + str(args.seed), 'data' + str(args.data_seed))
os.makedirs(log_dir, exist_ok=True)
args.log_dir = log_dir
logger = utils.Logger(file_name=f'{log_dir}/log.txt', file_mode="w+", should_flush=True)
ngpus = torch.cuda.device_count()
adv_batch_size = args.adv_batch_size * ngpus
print(f'ngpus: {ngpus}, adv_batch_size: {adv_batch_size}')
# load model
print('starting the model and loader...')
model = SDE_Adv_Model(args, config)
if ngpus > 1:
model = torch.nn.DataParallel(model)
model = model.eval().to(config.device)
# load data
x_val, y_val = load_data(args, adv_batch_size)
# eval classifier and sde_adv against bpda attack
eval_bpda(args, config, model, x_val, y_val, adv_batch_size, log_dir)
logger.close()
def parse_args_and_config():
parser = argparse.ArgumentParser(description=globals()['__doc__'])
# diffusion models
parser.add_argument('--config', type=str, required=True, help='Path to the config file')
parser.add_argument('--data_seed', type=int, default=0, help='Random seed')
parser.add_argument('--seed', type=int, default=1234, help='Random seed')
parser.add_argument('--exp', type=str, default='exp', help='Path for saving running related data.')
parser.add_argument('--verbose', type=str, default='info', help='Verbose level: info | debug | warning | critical')
parser.add_argument('-i', '--image_folder', type=str, default='images', help="The folder name of samples")
parser.add_argument('--ni', action='store_true', help="No interaction. Suitable for Slurm Job launcher")
parser.add_argument('--sample_step', type=int, default=1, help='Total sampling steps')
parser.add_argument('--t', type=int, default=400, help='Sampling noise scale')
parser.add_argument('--t_delta', type=int, default=15, help='Perturbation range of sampling noise scale')
parser.add_argument('--rand_t', type=str2bool, default=False, help='Decide if randomize sampling noise scale')
parser.add_argument('--diffusion_type', type=str, default='ddpm', help='[ddpm, sde, celebahq-ddpm]')
parser.add_argument('--score_type', type=str, default='guided_diffusion', help='[guided_diffusion, score_sde]')
parser.add_argument('--eot_iter', type=int, default=20, help='only for rand version of autoattack')
parser.add_argument('--use_bm', action='store_true', help='whether to use brownian motion')
parser.add_argument('--eot_defense_reps', type=int, default=150)
parser.add_argument('--eot_attack_reps', type=int, default=15)
# adv
parser.add_argument('--domain', type=str, default='celebahq', help='which domain: celebahq, cat, car, imagenet')
parser.add_argument('--classifier_name', type=str, default='Eyeglasses', help='which classifier to use')
parser.add_argument('--partition', type=str, default='val')
parser.add_argument('--adv_batch_size', type=int, default=64)
parser.add_argument('--num_sub', type=int, default=1000, help='imagenet subset')
parser.add_argument('--adv_eps', type=float, default=0.07)
args = parser.parse_args()
# parse config file
with open(os.path.join('configs', args.config), 'r') as f:
config = yaml.safe_load(f)
new_config = utils.dict2namespace(config)
level = getattr(logging, args.verbose.upper(), None)
if not isinstance(level, int):
raise ValueError('level {} not supported'.format(args.verbose))
handler1 = logging.StreamHandler()
formatter = logging.Formatter('%(levelname)s - %(filename)s - %(asctime)s - %(message)s')
handler1.setFormatter(formatter)
logger = logging.getLogger()
logger.addHandler(handler1)
logger.setLevel(level)
args.image_folder = os.path.join(args.exp, args.image_folder)
os.makedirs(args.image_folder, exist_ok=True)
# add device
device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
logging.info("Using device: {}".format(device))
new_config.device = device
# set random seed
torch.manual_seed(args.seed)
random.seed(args.seed)
np.random.seed(args.seed)
if torch.cuda.is_available():
torch.cuda.manual_seed_all(args.seed)
torch.backends.cudnn.benchmark = True
return args, new_config
if __name__ == '__main__':
args, config = parse_args_and_config()
# os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu_ids
robustness_eval(args, config)
| 11,271 | 39.257143 | 127 | py |
DiffPure | DiffPure-master/utils.py | # ---------------------------------------------------------------
# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# This work is licensed under the NVIDIA Source Code License
# for DiffPure. To view a copy of this license, see the LICENSE file.
# ---------------------------------------------------------------
import sys
import argparse
from typing import Any
import torch
import torch.nn as nn
import torchvision.models as models
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
from robustbench import load_model
import data
def compute_n_params(model, return_str=True):
tot = 0
for p in model.parameters():
w = 1
for x in p.shape:
w *= x
tot += w
if return_str:
if tot >= 1e6:
return '{:.1f}M'.format(tot / 1e6)
else:
return '{:.1f}K'.format(tot / 1e3)
else:
return tot
class Logger(object):
"""
Redirect stderr to stdout, optionally print stdout to a file,
and optionally force flushing on both stdout and the file.
"""
def __init__(self, file_name: str = None, file_mode: str = "w", should_flush: bool = True):
self.file = None
if file_name is not None:
self.file = open(file_name, file_mode)
self.should_flush = should_flush
self.stdout = sys.stdout
self.stderr = sys.stderr
sys.stdout = self
sys.stderr = self
def __enter__(self) -> "Logger":
return self
def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
self.close()
def write(self, text: str) -> None:
"""Write text to stdout (and a file) and optionally flush."""
if len(text) == 0: # workaround for a bug in VSCode debugger: sys.stdout.write(''); sys.stdout.flush() => crash
return
if self.file is not None:
self.file.write(text)
self.stdout.write(text)
if self.should_flush:
self.flush()
def flush(self) -> None:
"""Flush written text to both stdout and a file, if open."""
if self.file is not None:
self.file.flush()
self.stdout.flush()
def close(self) -> None:
"""Flush, close possible files, and remove stdout/stderr mirroring."""
self.flush()
# if using multiple loggers, prevent closing in wrong order
if sys.stdout is self:
sys.stdout = self.stdout
if sys.stderr is self:
sys.stderr = self.stderr
if self.file is not None:
self.file.close()
def dict2namespace(config):
namespace = argparse.Namespace()
for key, value in config.items():
if isinstance(value, dict):
new_value = dict2namespace(value)
else:
new_value = value
setattr(namespace, key, new_value)
return namespace
def str2bool(v):
if isinstance(v, bool):
return v
if v.lower() in ('yes', 'true', 't', 'y', '1'):
return True
elif v.lower() in ('no', 'false', 'f', 'n', '0'):
return False
else:
raise argparse.ArgumentTypeError('Boolean value expected.')
def update_state_dict(state_dict, idx_start=9):
from collections import OrderedDict
new_state_dict = OrderedDict()
for k, v in state_dict.items():
name = k[idx_start:] # remove 'module.0.' of dataparallel
new_state_dict[name]=v
return new_state_dict
# ------------------------------------------------------------------------
def get_accuracy(model, x_orig, y_orig, bs=64, device=torch.device('cuda:0')):
n_batches = x_orig.shape[0] // bs
acc = 0.
for counter in range(n_batches):
x = x_orig[counter * bs:min((counter + 1) * bs, x_orig.shape[0])].clone().to(device)
y = y_orig[counter * bs:min((counter + 1) * bs, x_orig.shape[0])].clone().to(device)
output = model(x)
acc += (output.max(1)[1] == y).float().sum()
return (acc / x_orig.shape[0]).item()
def get_image_classifier(classifier_name):
class _Wrapper_ResNet(nn.Module):
def __init__(self, resnet):
super().__init__()
self.resnet = resnet
self.mu = torch.Tensor([0.485, 0.456, 0.406]).float().view(3, 1, 1)
self.sigma = torch.Tensor([0.229, 0.224, 0.225]).float().view(3, 1, 1)
def forward(self, x):
x = (x - self.mu.to(x.device)) / self.sigma.to(x.device)
return self.resnet(x)
if 'imagenet' in classifier_name:
if 'resnet18' in classifier_name:
print('using imagenet resnet18...')
model = models.resnet18(pretrained=True).eval()
elif 'resnet50' in classifier_name:
print('using imagenet resnet50...')
model = models.resnet50(pretrained=True).eval()
elif 'resnet101' in classifier_name:
print('using imagenet resnet101...')
model = models.resnet101(pretrained=True).eval()
elif 'wideresnet-50-2' in classifier_name:
print('using imagenet wideresnet-50-2...')
model = models.wide_resnet50_2(pretrained=True).eval()
elif 'deit-s' in classifier_name:
print('using imagenet deit-s...')
model = torch.hub.load('facebookresearch/deit:main', 'deit_small_patch16_224', pretrained=True).eval()
else:
raise NotImplementedError(f'unknown {classifier_name}')
wrapper_resnet = _Wrapper_ResNet(model)
elif 'cifar10' in classifier_name:
if 'wideresnet-28-10' in classifier_name:
print('using cifar10 wideresnet-28-10...')
model = load_model(model_name='Standard', dataset='cifar10', threat_model='Linf') # pixel in [0, 1]
elif 'wrn-28-10-at0' in classifier_name:
print('using cifar10 wrn-28-10-at0...')
model = load_model(model_name='Gowal2021Improving_28_10_ddpm_100m', dataset='cifar10',
threat_model='Linf') # pixel in [0, 1]
elif 'wrn-28-10-at1' in classifier_name:
print('using cifar10 wrn-28-10-at1...')
model = load_model(model_name='Gowal2020Uncovering_28_10_extra', dataset='cifar10',
threat_model='Linf') # pixel in [0, 1]
elif 'wrn-70-16-at0' in classifier_name:
print('using cifar10 wrn-70-16-at0...')
model = load_model(model_name='Gowal2021Improving_70_16_ddpm_100m', dataset='cifar10',
threat_model='Linf') # pixel in [0, 1]
elif 'wrn-70-16-at1' in classifier_name:
print('using cifar10 wrn-70-16-at1...')
model = load_model(model_name='Rebuffi2021Fixing_70_16_cutmix_extra', dataset='cifar10',
threat_model='Linf') # pixel in [0, 1]
elif 'wrn-70-16-L2-at1' in classifier_name:
print('using cifar10 wrn-70-16-L2-at1...')
model = load_model(model_name='Rebuffi2021Fixing_70_16_cutmix_extra', dataset='cifar10',
threat_model='L2') # pixel in [0, 1]
elif 'wideresnet-70-16' in classifier_name:
print('using cifar10 wideresnet-70-16 (dm_wrn-70-16)...')
from robustbench.model_zoo.architectures.dm_wide_resnet import DMWideResNet, Swish
model = DMWideResNet(num_classes=10, depth=70, width=16, activation_fn=Swish) # pixel in [0, 1]
model_path = 'pretrained/cifar10/wresnet-76-10/weights-best.pt'
print(f"=> loading wideresnet-70-16 checkpoint '{model_path}'")
model.load_state_dict(update_state_dict(torch.load(model_path)['model_state_dict']))
model.eval()
print(f"=> loaded wideresnet-70-16 checkpoint")
elif 'resnet-50' in classifier_name:
print('using cifar10 resnet-50...')
from classifiers.cifar10_resnet import ResNet50
model = ResNet50() # pixel in [0, 1]
model_path = 'pretrained/cifar10/resnet-50/weights.pt'
print(f"=> loading resnet-50 checkpoint '{model_path}'")
model.load_state_dict(update_state_dict(torch.load(model_path), idx_start=7))
model.eval()
print(f"=> loaded resnet-50 checkpoint")
elif 'wrn-70-16-dropout' in classifier_name:
print('using cifar10 wrn-70-16-dropout (standard wrn-70-16-dropout)...')
from classifiers.cifar10_resnet import WideResNet_70_16_dropout
model = WideResNet_70_16_dropout() # pixel in [0, 1]
model_path = 'pretrained/cifar10/wrn-70-16-dropout/weights.pt'
print(f"=> loading wrn-70-16-dropout checkpoint '{model_path}'")
model.load_state_dict(update_state_dict(torch.load(model_path), idx_start=7))
model.eval()
print(f"=> loaded wrn-70-16-dropout checkpoint")
else:
raise NotImplementedError(f'unknown {classifier_name}')
wrapper_resnet = model
elif 'celebahq' in classifier_name:
attribute = classifier_name.split('__')[-1] # `celebahq__Smiling`
ckpt_path = f'pretrained/celebahq/{attribute}/net_best.pth'
from classifiers.attribute_classifier import ClassifierWrapper
model = ClassifierWrapper(attribute, ckpt_path=ckpt_path)
wrapper_resnet = model
else:
raise NotImplementedError(f'unknown {classifier_name}')
return wrapper_resnet
def load_data(args, adv_batch_size):
if 'imagenet' in args.domain:
val_dir = './dataset/imagenet_lmdb/val' # using imagenet lmdb data
val_transform = data.get_transform(args.domain, 'imval', base_size=224)
val_data = data.imagenet_lmdb_dataset_sub(val_dir, transform=val_transform,
num_sub=args.num_sub, data_seed=args.data_seed)
n_samples = len(val_data)
val_loader = DataLoader(val_data, batch_size=n_samples, shuffle=False, pin_memory=True, num_workers=4)
x_val, y_val = next(iter(val_loader))
elif 'cifar10' in args.domain:
data_dir = './dataset'
transform = transforms.Compose([transforms.ToTensor()])
val_data = data.cifar10_dataset_sub(data_dir, transform=transform,
num_sub=args.num_sub, data_seed=args.data_seed)
n_samples = len(val_data)
val_loader = DataLoader(val_data, batch_size=n_samples, shuffle=False, pin_memory=True, num_workers=4)
x_val, y_val = next(iter(val_loader))
elif 'celebahq' in args.domain:
data_dir = './dataset/celebahq'
attribute = args.classifier_name.split('__')[-1] # `celebahq__Smiling`
val_transform = data.get_transform('celebahq', 'imval')
clean_dset = data.get_dataset('celebahq', 'val', attribute, root=data_dir, transform=val_transform,
fraction=2, data_seed=args.data_seed) # data_seed randomizes here
loader = DataLoader(clean_dset, batch_size=adv_batch_size, shuffle=False,
pin_memory=True, num_workers=4)
x_val, y_val = next(iter(loader)) # [0, 1], 256x256
else:
raise NotImplementedError(f'Unknown domain: {args.domain}!')
print(f'x_val shape: {x_val.shape}')
x_val, y_val = x_val.contiguous().requires_grad_(True), y_val.contiguous()
print(f'x (min, max): ({x_val.min()}, {x_val.max()})')
return x_val, y_val
| 11,516 | 38.713793 | 119 | py |
DiffPure | DiffPure-master/eval_sde_adv.py | # ---------------------------------------------------------------
# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# This work is licensed under the NVIDIA Source Code License
# for DiffPure. To view a copy of this license, see the LICENSE file.
# ---------------------------------------------------------------
import argparse
import logging
import yaml
import os
import time
import random
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from autoattack import AutoAttack
from stadv_eot.attacks import StAdvAttack
import utils
from utils import str2bool, get_accuracy, get_image_classifier, load_data
from runners.diffpure_ddpm import Diffusion
from runners.diffpure_guided import GuidedDiffusion
from runners.diffpure_sde import RevGuidedDiffusion
from runners.diffpure_ode import OdeGuidedDiffusion
from runners.diffpure_ldsde import LDGuidedDiffusion
class SDE_Adv_Model(nn.Module):
def __init__(self, args, config):
super().__init__()
self.args = args
# image classifier
self.classifier = get_image_classifier(args.classifier_name).to(config.device)
# diffusion model
print(f'diffusion_type: {args.diffusion_type}')
if args.diffusion_type == 'ddpm':
self.runner = GuidedDiffusion(args, config, device=config.device)
elif args.diffusion_type == 'sde':
self.runner = RevGuidedDiffusion(args, config, device=config.device)
elif args.diffusion_type == 'ode':
self.runner = OdeGuidedDiffusion(args, config, device=config.device)
elif args.diffusion_type == 'ldsde':
self.runner = LDGuidedDiffusion(args, config, device=config.device)
elif args.diffusion_type == 'celebahq-ddpm':
self.runner = Diffusion(args, config, device=config.device)
else:
raise NotImplementedError('unknown diffusion type')
# use `counter` to record the the sampling time every 5 NFEs (note we hardcoded print freq to 5,
# and you may want to change the freq)
self.register_buffer('counter', torch.zeros(1, device=config.device))
self.tag = None
def reset_counter(self):
self.counter = torch.zeros(1, dtype=torch.int, device=config.device)
def set_tag(self, tag=None):
self.tag = tag
def forward(self, x):
counter = self.counter.item()
if counter % 5 == 0:
print(f'diffusion times: {counter}')
# imagenet [3, 224, 224] -> [3, 256, 256] -> [3, 224, 224]
if 'imagenet' in self.args.domain:
x = F.interpolate(x, size=(256, 256), mode='bilinear', align_corners=False)
start_time = time.time()
x_re = self.runner.image_editing_sample((x - 0.5) * 2, bs_id=counter, tag=self.tag)
minutes, seconds = divmod(time.time() - start_time, 60)
if 'imagenet' in self.args.domain:
x_re = F.interpolate(x_re, size=(224, 224), mode='bilinear', align_corners=False)
if counter % 5 == 0:
print(f'x shape (before diffusion models): {x.shape}')
print(f'x shape (before classifier): {x_re.shape}')
print("Sampling time per batch: {:0>2}:{:05.2f}".format(int(minutes), seconds))
out = self.classifier((x_re + 1) * 0.5)
self.counter += 1
return out
def eval_autoattack(args, config, model, x_val, y_val, adv_batch_size, log_dir):
ngpus = torch.cuda.device_count()
model_ = model
if ngpus > 1:
model_ = model.module
attack_version = args.attack_version # ['standard', 'rand', 'custom']
if attack_version == 'standard':
attack_list = ['apgd-ce', 'apgd-t', 'fab-t', 'square']
elif attack_version == 'rand':
attack_list = ['apgd-ce', 'apgd-dlr']
elif attack_version == 'custom':
attack_list = args.attack_type.split(',')
else:
raise NotImplementedError(f'Unknown attack version: {attack_version}!')
print(f'attack_version: {attack_version}, attack_list: {attack_list}') # ['apgd-ce', 'apgd-t', 'fab-t', 'square']
# ---------------- apply the attack to classifier ----------------
print(f'apply the attack to classifier [{args.lp_norm}]...')
classifier = get_image_classifier(args.classifier_name).to(config.device)
adversary_resnet = AutoAttack(classifier, norm=args.lp_norm, eps=args.adv_eps,
version=attack_version, attacks_to_run=attack_list,
log_path=f'{log_dir}/log_resnet.txt', device=config.device)
if attack_version == 'custom':
adversary_resnet.apgd.n_restarts = 1
adversary_resnet.fab.n_restarts = 1
adversary_resnet.apgd_targeted.n_restarts = 1
adversary_resnet.fab.n_target_classes = 9
adversary_resnet.apgd_targeted.n_target_classes = 9
adversary_resnet.square.n_queries = 5000
if attack_version == 'rand':
adversary_resnet.apgd.eot_iter = args.eot_iter
print(f'[classifier] rand version with eot_iter: {adversary_resnet.apgd.eot_iter}')
print(f'{args.lp_norm}, epsilon: {args.adv_eps}')
x_adv_resnet = adversary_resnet.run_standard_evaluation(x_val, y_val, bs=adv_batch_size)
print(f'x_adv_resnet shape: {x_adv_resnet.shape}')
torch.save([x_adv_resnet, y_val], f'{log_dir}/x_adv_resnet_sd{args.seed}.pt')
# ---------------- apply the attack to sde_adv ----------------
print(f'apply the attack to sde_adv [{args.lp_norm}]...')
model_.reset_counter()
adversary_sde = AutoAttack(model, norm=args.lp_norm, eps=args.adv_eps,
version=attack_version, attacks_to_run=attack_list,
log_path=f'{log_dir}/log_sde_adv.txt', device=config.device)
if attack_version == 'custom':
adversary_sde.apgd.n_restarts = 1
adversary_sde.fab.n_restarts = 1
adversary_sde.apgd_targeted.n_restarts = 1
adversary_sde.fab.n_target_classes = 9
adversary_sde.apgd_targeted.n_target_classes = 9
adversary_sde.square.n_queries = 5000
if attack_version == 'rand':
adversary_sde.apgd.eot_iter = args.eot_iter
print(f'[adv_sde] rand version with eot_iter: {adversary_sde.apgd.eot_iter}')
print(f'{args.lp_norm}, epsilon: {args.adv_eps}')
x_adv_sde = adversary_sde.run_standard_evaluation(x_val, y_val, bs=adv_batch_size)
print(f'x_adv_sde shape: {x_adv_sde.shape}')
torch.save([x_adv_sde, y_val], f'{log_dir}/x_adv_sde_sd{args.seed}.pt')
def eval_stadv(args, config, model, x_val, y_val, adv_batch_size, log_dir):
ngpus = torch.cuda.device_count()
model_ = model
if ngpus > 1:
model_ = model.module
x_val, y_val = x_val.to(config.device), y_val.to(config.device)
print(f'bound: {args.adv_eps}')
# apply the attack to resnet
print(f'apply the stadv attack to resnet...')
resnet = get_image_classifier(args.classifier_name).to(config.device)
start_time = time.time()
init_acc = get_accuracy(resnet, x_val, y_val, bs=adv_batch_size)
print('initial accuracy: {:.2%}, time elapsed: {:.2f}s'.format(init_acc, time.time() - start_time))
adversary_resnet = StAdvAttack(resnet, bound=args.adv_eps, num_iterations=100, eot_iter=args.eot_iter)
start_time = time.time()
x_adv_resnet = adversary_resnet(x_val, y_val)
robust_acc = get_accuracy(resnet, x_adv_resnet, y_val, bs=adv_batch_size)
print('robust accuracy: {:.2%}, time elapsed: {:.2f}s'.format(robust_acc, time.time() - start_time))
print(f'x_adv_resnet shape: {x_adv_resnet.shape}')
torch.save([x_adv_resnet, y_val], f'{log_dir}/x_adv_resnet_sd{args.seed}.pt')
# apply the attack to sde_adv
print(f'apply the stadv attack to sde_adv...')
start_time = time.time()
model_.reset_counter()
model_.set_tag('no_adv')
init_acc = get_accuracy(model, x_val, y_val, bs=adv_batch_size)
print('initial accuracy: {:.2%}, time elapsed: {:.2f}s'.format(init_acc, time.time() - start_time))
adversary_sde = StAdvAttack(model, bound=args.adv_eps, num_iterations=100, eot_iter=args.eot_iter)
start_time = time.time()
model_.reset_counter()
model_.set_tag()
x_adv_sde = adversary_sde(x_val, y_val)
model_.reset_counter()
model_.set_tag('sde_adv')
robust_acc = get_accuracy(model, x_adv_sde, y_val, bs=adv_batch_size)
print('robust accuracy: {:.2%}, time elapsed: {:.2f}s'.format(robust_acc, time.time() - start_time))
print(f'x_adv_sde shape: {x_adv_sde.shape}')
torch.save([x_adv_sde, y_val], f'{log_dir}/x_adv_sde_sd{args.seed}.pt')
def robustness_eval(args, config):
middle_name = '_'.join([args.diffusion_type, args.attack_version]) if args.attack_version in ['stadv', 'standard', 'rand'] \
else '_'.join([args.diffusion_type, args.attack_version, args.attack_type])
log_dir = os.path.join(args.image_folder, args.classifier_name, middle_name,
'seed' + str(args.seed), 'data' + str(args.data_seed))
os.makedirs(log_dir, exist_ok=True)
args.log_dir = log_dir
logger = utils.Logger(file_name=f'{log_dir}/log.txt', file_mode="w+", should_flush=True)
ngpus = torch.cuda.device_count()
adv_batch_size = args.adv_batch_size * ngpus
print(f'ngpus: {ngpus}, adv_batch_size: {adv_batch_size}')
# load model
print('starting the model and loader...')
model = SDE_Adv_Model(args, config)
if ngpus > 1:
model = torch.nn.DataParallel(model)
model = model.eval().to(config.device)
# load data
x_val, y_val = load_data(args, adv_batch_size)
# eval classifier and sde_adv against attacks
if args.attack_version in ['standard', 'rand', 'custom']:
eval_autoattack(args, config, model, x_val, y_val, adv_batch_size, log_dir)
elif args.attack_version == 'stadv':
eval_stadv(args, config, model, x_val, y_val, adv_batch_size, log_dir)
else:
raise NotImplementedError(f'unknown attack_version: {args.attack_version}')
logger.close()
def parse_args_and_config():
parser = argparse.ArgumentParser(description=globals()['__doc__'])
# diffusion models
parser.add_argument('--config', type=str, required=True, help='Path to the config file')
parser.add_argument('--data_seed', type=int, default=0, help='Random seed')
parser.add_argument('--seed', type=int, default=1234, help='Random seed')
parser.add_argument('--exp', type=str, default='exp', help='Path for saving running related data.')
parser.add_argument('--verbose', type=str, default='info', help='Verbose level: info | debug | warning | critical')
parser.add_argument('-i', '--image_folder', type=str, default='images', help="The folder name of samples")
parser.add_argument('--ni', action='store_true', help="No interaction. Suitable for Slurm Job launcher")
parser.add_argument('--sample_step', type=int, default=1, help='Total sampling steps')
parser.add_argument('--t', type=int, default=400, help='Sampling noise scale')
parser.add_argument('--t_delta', type=int, default=15, help='Perturbation range of sampling noise scale')
parser.add_argument('--rand_t', type=str2bool, default=False, help='Decide if randomize sampling noise scale')
parser.add_argument('--diffusion_type', type=str, default='ddpm', help='[ddpm, sde]')
parser.add_argument('--score_type', type=str, default='guided_diffusion', help='[guided_diffusion, score_sde]')
parser.add_argument('--eot_iter', type=int, default=20, help='only for rand version of autoattack')
parser.add_argument('--use_bm', action='store_true', help='whether to use brownian motion')
# LDSDE
parser.add_argument('--sigma2', type=float, default=1e-3, help='LDSDE sigma2')
parser.add_argument('--lambda_ld', type=float, default=1e-2, help='lambda_ld')
parser.add_argument('--eta', type=float, default=5., help='LDSDE eta')
parser.add_argument('--step_size', type=float, default=1e-3, help='step size for ODE Euler method')
# adv
parser.add_argument('--domain', type=str, default='celebahq', help='which domain: celebahq, cat, car, imagenet')
parser.add_argument('--classifier_name', type=str, default='Eyeglasses', help='which classifier to use')
parser.add_argument('--partition', type=str, default='val')
parser.add_argument('--adv_batch_size', type=int, default=64)
parser.add_argument('--attack_type', type=str, default='square')
parser.add_argument('--lp_norm', type=str, default='Linf', choices=['Linf', 'L2'])
parser.add_argument('--attack_version', type=str, default='custom')
parser.add_argument('--num_sub', type=int, default=1000, help='imagenet subset')
parser.add_argument('--adv_eps', type=float, default=0.07)
args = parser.parse_args()
# parse config file
with open(os.path.join('configs', args.config), 'r') as f:
config = yaml.safe_load(f)
new_config = utils.dict2namespace(config)
level = getattr(logging, args.verbose.upper(), None)
if not isinstance(level, int):
raise ValueError('level {} not supported'.format(args.verbose))
handler1 = logging.StreamHandler()
formatter = logging.Formatter('%(levelname)s - %(filename)s - %(asctime)s - %(message)s')
handler1.setFormatter(formatter)
logger = logging.getLogger()
logger.addHandler(handler1)
logger.setLevel(level)
args.image_folder = os.path.join(args.exp, args.image_folder)
os.makedirs(args.image_folder, exist_ok=True)
# add device
device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
logging.info("Using device: {}".format(device))
new_config.device = device
# set random seed
torch.manual_seed(args.seed)
random.seed(args.seed)
np.random.seed(args.seed)
if torch.cuda.is_available():
torch.cuda.manual_seed_all(args.seed)
torch.backends.cudnn.benchmark = True
return args, new_config
if __name__ == '__main__':
args, config = parse_args_and_config()
# os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu_ids
robustness_eval(args, config)
| 14,171 | 42.740741 | 128 | py |
DiffPure | DiffPure-master/stadv_eot/attacks.py | # ---------------------------------------------------------------
# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# This work is licensed under the NVIDIA Source Code License
# for DiffPure. To view a copy of this license, see the LICENSE file.
# ---------------------------------------------------------------
import functools
import torch
from torch import nn
from torch import optim
# mister_ed
from .recoloradv.mister_ed import loss_functions as lf
from .recoloradv.mister_ed import adversarial_training as advtrain
from .recoloradv.mister_ed import adversarial_perturbations as ap
from .recoloradv.mister_ed import adversarial_attacks as aa
from .recoloradv.mister_ed import spatial_transformers as st
PGD_ITERS = 20
def run_attack_with_random_targets(attack, model, inputs, labels, num_classes):
"""
Runs an attack with targets randomly selected from all classes besides the
correct one. The attack should be a function from (inputs, labels) to
adversarial examples.
"""
rand_targets = torch.randint(
0, num_classes - 1, labels.size(),
dtype=labels.dtype, device=labels.device,
)
targets = torch.remainder(labels + rand_targets + 1, num_classes)
adv_inputs = attack(inputs, targets)
adv_labels = model(adv_inputs).argmax(1)
unsuccessful = adv_labels != targets
adv_inputs[unsuccessful] = inputs[unsuccessful]
return adv_inputs
class MisterEdAttack(nn.Module):
"""
Base class for attacks using the mister_ed library.
"""
def __init__(self, model, threat_model, randomize=False,
perturbation_norm_loss=False, lr=0.001, random_targets=False,
num_classes=None, **kwargs):
super().__init__()
self.model = model
self.normalizer = nn.Identity()
self.threat_model = threat_model
self.randomize = randomize
self.perturbation_norm_loss = perturbation_norm_loss
self.attack_kwargs = kwargs
self.lr = lr
self.random_targets = random_targets
self.num_classes = num_classes
self.attack = None
def _setup_attack(self):
cw_loss = lf.CWLossF6(self.model, self.normalizer, kappa=float('inf'))
if self.random_targets:
cw_loss.forward = functools.partial(cw_loss.forward, targeted=True)
perturbation_loss = lf.PerturbationNormLoss(lp=2)
pert_factor = 0.0
if self.perturbation_norm_loss is True:
pert_factor = 0.05
elif type(self.perturbation_norm_loss) is float:
pert_factor = self.perturbation_norm_loss
adv_loss = lf.RegularizedLoss({
'cw': cw_loss,
'pert': perturbation_loss,
}, {
'cw': 1.0,
'pert': pert_factor,
}, negate=True)
self.pgd_attack = aa.PGD(self.model, self.normalizer,
self.threat_model(), adv_loss)
attack_params = {
'optimizer': optim.Adam,
'optimizer_kwargs': {'lr': self.lr},
'signed': False,
'verbose': False,
'num_iterations': 0 if self.randomize else PGD_ITERS,
'random_init': self.randomize,
}
attack_params.update(self.attack_kwargs)
self.attack = advtrain.AdversarialAttackParameters(
self.pgd_attack,
1.0,
attack_specific_params={'attack_kwargs': attack_params},
)
self.attack.set_gpu(False)
def forward(self, inputs, labels):
if self.attack is None:
self._setup_attack()
assert self.attack is not None
if self.random_targets:
return run_attack_with_random_targets(
lambda inputs, labels: self.attack.attack(inputs, labels)[0],
self.model,
inputs,
labels,
num_classes=self.num_classes,
)
else:
return self.attack.attack(inputs, labels)[0]
class StAdvAttack(MisterEdAttack):
def __init__(self, model, bound=0.05, **kwargs):
kwargs.setdefault('lr', 0.01)
super().__init__(
model,
threat_model=lambda: ap.ThreatModel(ap.ParameterizedXformAdv, {
'lp_style': 'inf',
'lp_bound': bound,
'xform_class': st.FullSpatial,
'use_stadv': True,
}),
perturbation_norm_loss=0.0025 / bound,
**kwargs,
)
| 4,525 | 32.036496 | 79 | py |
DiffPure | DiffPure-master/stadv_eot/recoloradv/color_transformers.py | # ---------------------------------------------------------------
# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# This file has been modified from recoloradv.
#
# Source:
# https://github.com/cassidylaidlaw/ReColorAdv/blob/master/recoloradv/color_transformers.py
#
# The license for the original version of this file can be
# found in this directory (LICENSE_RECOLORADV).
# The modifications to this file are subject to the same license.
# ---------------------------------------------------------------
"""
Contains various parameterizations for spatial transformation in 3D color space.
"""
import torch
import torch.nn as nn
from .mister_ed.utils import pytorch_utils as utils
from torch.autograd import Variable
from . import norms
from functools import lru_cache
##############################################################################
# #
# SKELETON CLASS #
# #
##############################################################################
class ParameterizedTransformation(nn.Module):
""" General class of transformations.
All subclasses need the following methods:
- norm: no args -> scalar variable
- identity_params: shape -> TENSOR : takes an input shape and outputs
the subclass-specific parameter for the identity
transformation
- forward : Variable -> Variable - is the transformation
"""
def __init__(self, **kwargs):
super(ParameterizedTransformation, self).__init__()
if kwargs.get('manual_gpu', None) is not None:
self.use_gpu = kwargs['manual_gpu']
else:
self.use_gpu = utils.use_gpu()
def clone(self, shape=None, example_index=None):
raise NotImplementedError()
def norm(self, lp='inf'):
raise NotImplementedError("Need to call subclass's norm!")
@classmethod
def identity_params(self, shape):
raise NotImplementedError("Need to call subclass's identity_params!")
def merge_xform(self, other, self_mask):
""" Takes in an other instance of this same class with the same
shape of parameters (NxSHAPE) and a self_mask bytetensor of length
N and outputs the merge between self's parameters for the indices
of 1s in the self_mask and other's parameters for the indices of 0's
ARGS:
other: instance of same class as self with params of shape NxSHAPE -
the thing we merge with this one
self_mask : ByteTensor (length N) - which indices of parameters we
keep from self, and which we keep from other
RETURNS:
New instance of this class that's merged between the self and other
(same shaped params)
"""
# JUST DO ASSERTS IN THE SKELETON CLASS
assert self.__class__ == other.__class__
self_params = self.xform_params.data
other_params = other.xform_params.data
assert self_params.shape == other_params.shape
assert self_params.shape[0] == self_mask.shape[0]
assert other_params.shape[0] == self_mask.shape[0]
new_xform = self.__class__(shape=self.img_shape)
new_params = utils.fold_mask(self.xform_params.data,
other.xform_params.data, self_mask)
new_xform.xform_params = nn.Parameter(new_params)
new_xform.use_gpu = self.use_gpu
return new_xform
def forward(self, examples):
raise NotImplementedError("Need to call subclass's forward!")
class AffineTransform(ParameterizedTransformation):
def __init__(self, *args, **kwargs):
super(AffineTransform, self).__init__(**kwargs)
img_shape = kwargs['shape']
self.img_shape = img_shape
self.xform_params = nn.Parameter(self.identity_params(img_shape))
def clone(self, shape=None, example_index=None):
xform = AffineTransform(shape=shape or self.img_shape)
if example_index is None:
my_params = self.xform_params
else:
my_params = self.xform_params[example_index][None]
xform.xform_params = nn.Parameter(
my_params.clone()
.expand(shape[0], -1, -1)
)
return xform
def norm(self, lp='inf'):
identity_params = Variable(self.identity_params(self.img_shape))
return utils.batchwise_norm(self.xform_params - identity_params, lp,
dim=0)
def identity_params(self, shape):
num_examples = shape[0]
identity_affine_transform = torch.zeros(num_examples, 3, 4)
if self.use_gpu:
identity_affine_transform = identity_affine_transform.cuda()
identity_affine_transform[:, 0, 0] = 1
identity_affine_transform[:, 1, 1] = 1
identity_affine_transform[:, 2, 2] = 1
return identity_affine_transform
def project_params(self, lp, lp_bound):
assert isinstance(lp, int) or lp == 'inf'
diff = self.xform_params.data - self.identity_params(self.img_shape)
new_diff = utils.batchwise_lp_project(diff, lp, lp_bound)
self.xform_params.data.add_(new_diff - diff)
def forward(self, x):
N, _, W, H = self.img_shape
x_padded = torch.cat([x, torch.ones(N, 1, W, H)], 1).permute(
0, 2, 3, 1)
transform_padded = self.xform_params[:, None, None, :, :] \
.expand(-1, W, H, -1, -1)
x_transformed = transform_padded.matmul(x_padded[..., None]) \
.squeeze(4) \
.permute(0, 3, 1, 2)
return x_transformed
class FullSpatial(ParameterizedTransformation):
def __init__(self, *args, resolution_x=8,
resolution_y=8, resolution_z=8, **kwargs):
super(FullSpatial, self).__init__(**kwargs)
self.resolution_x = resolution_x
self.resolution_y = resolution_y
self.resolution_z = resolution_z
img_shape = kwargs['shape']
self.img_shape = img_shape
self.cspace = kwargs.get('cspace')
batch_size = self.img_shape[0]
self.identity_params = FullSpatial.construct_identity_params(
batch_size,
self.resolution_x,
self.resolution_y,
self.resolution_z,
torch.cuda.current_device() if self.use_gpu else None,
)
self.xform_params = nn.Parameter(
torch.empty_like(self.identity_params)
.copy_(self.identity_params)
)
def clone(self, shape=None, example_index=None):
xform = FullSpatial(
shape=shape or self.img_shape,
resolution_x=self.resolution_x,
resolution_y=self.resolution_y,
resolution_z=self.resolution_z,
cspace=self.cspace,
)
if example_index is None:
my_params = self.xform_params
else:
my_params = self.xform_params[example_index][None]
xform.xform_params = nn.Parameter(
my_params.clone()
.expand(shape[0], -1, -1, -1, -1)
)
return xform
def smoothness_norm(self):
return norms.smoothness(self.xform_params -
self.identity_params)
def norm(self, lp='inf'):
if isinstance(lp, int) or lp == 'inf':
return utils.batchwise_norm(
self.xform_params - self.identity_params,
lp, dim=0,
)
else:
assert lp == 'smooth'
return self.smoothness_norm()
def clip_params(self):
"""
Clips the parameters to be between 0 and 1 and also within the color
space's gamut.
"""
clamp_params = torch.clamp(self.xform_params, 0, 1).data
params_shape = self.xform_params.size()
flattened_params = (
clamp_params
.permute(0, 4, 1, 2, 3)
.reshape(params_shape[0], 3, -1, 1)
)
gamut_params = self.cspace.from_rgb(self.cspace.to_rgb(
flattened_params))
clamp_params = (
gamut_params
.permute(0, 2, 3, 1)
.reshape(*params_shape)
)
change_in_params = clamp_params - self.xform_params.data
self.xform_params.data.add_(change_in_params)
def merge_xform(self, other, self_mask):
"""
Takes in an other instance of this same class with the same
shape of parameters (NxSHAPE) and a self_mask bytetensor of length
N and outputs the merge between self's parameters for the indices
of 1s in the self_mask and other's parameters for the indices of 0's
"""
super().merge_xform(other, self_mask)
new_xform = FullSpatial(shape=self.img_shape,
manual_gpu=self.use_gpu,
resolution_x=self.resolution_x,
resolution_y=self.resolution_y,
resolution_z=self.resolution_z,
cspace=self.cspace)
new_params = utils.fold_mask(self.xform_params.data,
other.xform_params.data, self_mask)
new_xform.xform_params = nn.Parameter(new_params)
return new_xform
def project_params(self, lp, lp_bound):
"""
Projects the params to be within lp_bound (according to an lp)
of the identity map. First thing we do is clip the params to be
valid, too.
ARGS:
lp : int or 'inf' - which LP norm we use. Must be an int or the
string 'inf'.
lp_bound : float - how far we're allowed to go in LP land. Can be
a list to indicate that we can go more in some channels
than others.
RETURNS:
None, but modifies self.xform_params
"""
assert isinstance(lp, int) or lp == 'inf'
# clip first
self.clip_params()
# then project back
if lp == 'inf':
try:
# first, assume lp_bound is a vector, and then revert to scalar
# if it's not
clamped_channels = []
for channel_index, bound in enumerate(lp_bound):
clamped_channels.append(utils.clamp_ref(
self.xform_params[..., channel_index],
self.identity_params[..., channel_index],
bound,
))
clamp_params = torch.stack(clamped_channels, 4)
except TypeError:
clamp_params = utils.clamp_ref(self.xform_params.data,
self.identity_params, lp_bound)
change_in_params = clamp_params - self.xform_params.data
else:
flattened_params = (
self.xform_params.data -
self.identity_params
).reshape((-1, 3))
projected_params = flattened_params.renorm(lp, 0, lp_bound)
flattened_change = projected_params - flattened_params
change_in_params = flattened_change.reshape(
self.xform_params.size())
self.xform_params.data.add_(change_in_params)
def forward(self, imgs):
device = torch.device('cuda') if self.use_gpu else None
N, C, W, H = self.img_shape
imgs = imgs.permute(0, 2, 3, 1) # N x W x H x C
imgs = imgs * torch.tensor(
[
self.resolution_x - 1,
self.resolution_y - 1,
self.resolution_z - 1,
],
dtype=torch.float,
device=device,
)[None, None, None, :].expand(N, W, H, C)
integer_part, float_part = torch.floor(imgs).long(), imgs % 1
params_list = self.xform_params.view(N, -1, 3)
# do trilinear interpolation from the params grid
endpoint_values = []
for delta_x in [0, 1]:
corner_values = []
for delta_y in [0, 1]:
vertex_values = []
for delta_z in [0, 1]:
params_index = Variable(torch.zeros(
N, W, H,
dtype=torch.long,
device=device,
))
for color_index, resolution in [
(integer_part[..., 0] + delta_x, self.resolution_x),
(integer_part[..., 1] + delta_y, self.resolution_y),
(integer_part[..., 2] + delta_z, self.resolution_z),
]:
color_index = color_index.clamp(
0, resolution - 1)
params_index = (params_index * resolution +
color_index)
params_index = params_index.view(N, -1)[:, :, None] \
.expand(-1, -1, 3)
vertex_values.append(
params_list.gather(1, params_index)
.view(N, W, H, C)
)
corner_values.append(
vertex_values[0] * (1 - float_part[..., 2, None]) +
vertex_values[1] * float_part[..., 2, None]
)
endpoint_values.append(
corner_values[0] * (1 - float_part[..., 1, None]) +
corner_values[1] * float_part[..., 1, None]
)
result = (
endpoint_values[0] * (1 - float_part[..., 0, None]) +
endpoint_values[1] * float_part[..., 0, None]
)
return result.permute(0, 3, 1, 2)
@staticmethod
@lru_cache(maxsize=10)
def construct_identity_params(batch_size, resolution_x, resolution_y,
resolution_z, device):
identity_params = torch.empty(
batch_size, resolution_x, resolution_y,
resolution_z, 3,
dtype=torch.float,
device=device,
)
for x in range(resolution_x):
for y in range(resolution_y):
for z in range(resolution_z):
identity_params[:, x, y, z, 0] = \
x / (resolution_x - 1)
identity_params[:, x, y, z, 1] = \
y / (resolution_y - 1)
identity_params[:, x, y, z, 2] = \
z / (resolution_z - 1)
return identity_params
| 14,822 | 38.007895 | 91 | py |
DiffPure | DiffPure-master/stadv_eot/recoloradv/utils.py | # ---------------------------------------------------------------
# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# This file has been modified from recoloradv.
#
# Source:
# https://github.com/cassidylaidlaw/ReColorAdv/blob/master/recoloradv/utils.py
#
# The license for the original version of this file can be
# found in this directory (LICENSE_RECOLORADV).
# The modifications to this file are subject to the same license.
# ---------------------------------------------------------------
from torch import nn
from torch import optim
from .mister_ed.utils.pytorch_utils import DifferentiableNormalize
from .mister_ed import adversarial_perturbations as ap
from .mister_ed import adversarial_attacks as aa
from .mister_ed import spatial_transformers as st
from .mister_ed import loss_functions as lf
from .mister_ed import adversarial_training as advtrain
from . import perturbations as pt
from . import color_transformers as ct
from . import color_spaces as cs
def get_attack_from_name(
name: str,
classifier: nn.Module,
normalizer: DifferentiableNormalize,
verbose: bool = False,
) -> advtrain.AdversarialAttackParameters:
"""
Builds an attack from a name like "recoloradv" or "stadv+delta" or
"recoloradv+stadv+delta".
"""
threats = []
norm_weights = []
for attack_part in name.split('+'):
if attack_part == 'delta':
threats.append(ap.ThreatModel(
ap.DeltaAddition,
ap.PerturbationParameters(
lp_style='inf',
lp_bound=8.0 / 255,
),
))
norm_weights.append(0.0)
elif attack_part == 'stadv':
threats.append(ap.ThreatModel(
ap.ParameterizedXformAdv,
ap.PerturbationParameters(
lp_style='inf',
lp_bound=0.05,
xform_class=st.FullSpatial,
use_stadv=True,
),
))
norm_weights.append(1.0)
elif attack_part == 'recoloradv':
threats.append(ap.ThreatModel(
pt.ReColorAdv,
ap.PerturbationParameters(
lp_style='inf',
lp_bound=[0.06, 0.06, 0.06],
xform_params={
'resolution_x': 16,
'resolution_y': 32,
'resolution_z': 32,
},
xform_class=ct.FullSpatial,
use_smooth_loss=True,
cspace=cs.CIELUVColorSpace(),
),
))
norm_weights.append(1.0)
else:
raise ValueError(f'Invalid attack "{attack_part}"')
sequence_threat = ap.ThreatModel(
ap.SequentialPerturbation,
threats,
ap.PerturbationParameters(norm_weights=norm_weights),
)
# use PGD attack
adv_loss = lf.CWLossF6(classifier, normalizer, kappa=float('inf'))
st_loss = lf.PerturbationNormLoss(lp=2)
loss_fxn = lf.RegularizedLoss({'adv': adv_loss, 'pert': st_loss},
{'adv': 1.0, 'pert': 0.05},
negate=True)
pgd_attack = aa.PGD(classifier, normalizer, sequence_threat, loss_fxn)
return advtrain.AdversarialAttackParameters(
pgd_attack,
1.0,
attack_specific_params={'attack_kwargs': {
'num_iterations': 100,
'optimizer': optim.Adam,
'optimizer_kwargs': {'lr': 0.001},
'signed': False,
'verbose': verbose,
}},
)
| 3,667 | 32.651376 | 78 | py |
DiffPure | DiffPure-master/stadv_eot/recoloradv/norms.py | # ---------------------------------------------------------------
# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# This file has been modified from recoloradv.
#
# Source:
# https://github.com/cassidylaidlaw/ReColorAdv/blob/master/recoloradv/norms.py
#
# The license for the original version of this file can be
# found in this directory (LICENSE_RECOLORADV).
# The modifications to this file are subject to the same license.
# ---------------------------------------------------------------
import torch
from torch.autograd import Variable
def smoothness(grid):
"""
Given a variable of dimensions (N, X, Y, [Z], C), computes the sum of
the differences between adjacent points in the grid formed by the
dimensions X, Y, and (optionally) Z. Returns a tensor of dimension N.
"""
num_dims = len(grid.size()) - 2
batch_size = grid.size()[0]
norm = Variable(torch.zeros(batch_size, dtype=grid.data.dtype,
device=grid.data.device))
for dim in range(num_dims):
slice_before = (slice(None),) * (dim + 1)
slice_after = (slice(None),) * (num_dims - dim)
shifted_grids = [
# left
torch.cat([
grid[slice_before + (slice(1, None),) + slice_after],
grid[slice_before + (slice(-1, None),) + slice_after],
], dim + 1),
# right
torch.cat([
grid[slice_before + (slice(None, 1),) + slice_after],
grid[slice_before + (slice(None, -1),) + slice_after],
], dim + 1)
]
for shifted_grid in shifted_grids:
delta = shifted_grid - grid
norm_components = (delta.pow(2).sum(-1) + 1e-10).pow(0.5)
norm.add_(norm_components.sum(
tuple(range(1, len(norm_components.size())))))
return norm
| 1,881 | 35.192308 | 78 | py |
DiffPure | DiffPure-master/stadv_eot/recoloradv/perturbations.py | # ---------------------------------------------------------------
# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# This file has been modified from recoloradv.
#
# Source:
# https://github.com/cassidylaidlaw/ReColorAdv/blob/master/recoloradv/perturbations.py
#
# The license for the original version of this file can be
# found in this directory (LICENSE_RECOLORADV).
# The modifications to this file are subject to the same license.
# ---------------------------------------------------------------
from .mister_ed import adversarial_perturbations as ap
from .mister_ed.adversarial_perturbations import initialized
from .mister_ed.utils import pytorch_utils as utils
from . import color_transformers as ct
from . import color_spaces as cs
class ReColorAdv(ap.AdversarialPerturbation):
"""
Puts the color at each pixel in the image through the same transformation.
Parameters:
- lp_style: number or 'inf'
- lp_bound: maximum norm of color transformation. Can be a tensor of size
(num_channels,), in which case each channel will be bounded by the
cooresponding bound in the tensor. For instance, passing
[0.1, 0.15, 0.05] would allow a norm of 0.1 for R, 0.15 for G, and 0.05
for B. Not supported by all transformations.
- use_smooth_loss: whether to optimize using the loss function
for FullSpatial that rewards smooth vector fields
- xform_class: a subclass of
color_transformers.ParameterizedTransformation
- xform_params: dict of parameters to pass to the xform_class.
- cspace_class: a subclass of color_spaces.ColorSpace that indicates
in which color space the transformation should be performed
(RGB by default)
"""
def __init__(self, threat_model, perturbation_params, *other_args):
super().__init__(threat_model, perturbation_params)
assert issubclass(perturbation_params.xform_class,
ct.ParameterizedTransformation)
self.lp_style = perturbation_params.lp_style
self.lp_bound = perturbation_params.lp_bound
self.use_smooth_loss = perturbation_params.use_smooth_loss
self.scalar_step = perturbation_params.scalar_step or 1.0
self.cspace = perturbation_params.cspace or cs.RGBColorSpace()
def _merge_setup(self, num_examples, new_xform):
""" DANGEROUS TO BE CALLED OUTSIDE OF THIS FILE!!!"""
self.num_examples = num_examples
self.xform = new_xform
self.initialized = True
def setup(self, originals):
super().setup(originals)
self.xform = self.perturbation_params.xform_class(
shape=originals.shape, manual_gpu=self.use_gpu,
cspace=self.cspace,
**(self.perturbation_params.xform_params or {}),
)
self.initialized = True
@initialized
def perturbation_norm(self, x=None, lp_style=None):
lp_style = lp_style or self.lp_style
if self.use_smooth_loss:
assert isinstance(self.xform, ct.FullSpatial)
return self.xform.smoothness_norm()
else:
return self.xform.norm(lp=lp_style)
@initialized
def constrain_params(self, x=None):
# Do lp projections
if isinstance(self.lp_style, int) or self.lp_style == 'inf':
self.xform.project_params(self.lp_style, self.lp_bound)
@initialized
def update_params(self, step_fxn):
param_list = list(self.xform.parameters())
assert len(param_list) == 1
params = param_list[0]
assert params.grad.data is not None
self.add_to_params(step_fxn(params.grad.data) * self.scalar_step)
@initialized
def add_to_params(self, grad_data):
""" Assumes only one parameters object in the Spatial Transform """
param_list = list(self.xform.parameters())
assert len(param_list) == 1
params = param_list[0]
params.data.add_(grad_data)
@initialized
def random_init(self):
param_list = list(self.xform.parameters())
assert len(param_list) == 1
param = param_list[0]
random_perturb = utils.random_from_lp_ball(param.data,
self.lp_style,
self.lp_bound)
param.data.add_(self.xform.identity_params +
random_perturb - self.xform.xform_params.data)
@initialized
def merge_perturbation(self, other, self_mask):
super().merge_perturbation(other, self_mask)
new_perturbation = ReColorAdv(self.threat_model,
self.perturbation_params)
new_xform = self.xform.merge_xform(other.xform, self_mask)
new_perturbation._merge_setup(self.num_examples, new_xform)
return new_perturbation
def forward(self, x):
if not self.initialized:
self.setup(x)
self.constrain_params()
return self.cspace.to_rgb(
self.xform.forward(self.cspace.from_rgb(x)))
| 5,078 | 38.069231 | 86 | py |
DiffPure | DiffPure-master/stadv_eot/recoloradv/color_spaces.py | # ---------------------------------------------------------------
# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# This file has been modified from recoloradv.
#
# Source:
# https://github.com/cassidylaidlaw/ReColorAdv/blob/master/recoloradv/color_spaces.py
#
# The license for the original version of this file can be
# found in this directory (LICENSE_RECOLORADV).
# The modifications to this file are subject to the same license.
# ---------------------------------------------------------------
"""
Contains classes that convert from RGB to various other color spaces and back.
"""
import torch
import numpy as np
import math
class ColorSpace(object):
"""
Base class for color spaces.
"""
def from_rgb(self, imgs):
"""
Converts an Nx3xWxH tensor in RGB color space to a Nx3xWxH tensor in
this color space. All outputs should be in the 0-1 range.
"""
raise NotImplementedError()
def to_rgb(self, imgs):
"""
Converts an Nx3xWxH tensor in this color space to a Nx3xWxH tensor in
RGB color space.
"""
raise NotImplementedError()
class RGBColorSpace(ColorSpace):
"""
RGB color space. Just applies identity transformation.
"""
def from_rgb(self, imgs):
return imgs
def to_rgb(self, imgs):
return imgs
class YPbPrColorSpace(ColorSpace):
"""
YPbPr color space. Uses ITU-R BT.601 standard by default.
"""
def __init__(self, kr=0.299, kg=0.587, kb=0.114, luma_factor=1,
chroma_factor=1):
self.kr, self.kg, self.kb = kr, kg, kb
self.luma_factor = luma_factor
self.chroma_factor = chroma_factor
def from_rgb(self, imgs):
r, g, b = imgs.permute(1, 0, 2, 3)
y = r * self.kr + g * self.kg + b * self.kb
pb = (b - y) / (2 * (1 - self.kb))
pr = (r - y) / (2 * (1 - self.kr))
return torch.stack([y * self.luma_factor,
pb * self.chroma_factor + 0.5,
pr * self.chroma_factor + 0.5], 1)
def to_rgb(self, imgs):
y_prime, pb_prime, pr_prime = imgs.permute(1, 0, 2, 3)
y = y_prime / self.luma_factor
pb = (pb_prime - 0.5) / self.chroma_factor
pr = (pr_prime - 0.5) / self.chroma_factor
b = pb * 2 * (1 - self.kb) + y
r = pr * 2 * (1 - self.kr) + y
g = (y - r * self.kr - b * self.kb) / self.kg
return torch.stack([r, g, b], 1).clamp(0, 1)
class ApproxHSVColorSpace(ColorSpace):
"""
Converts from RGB to approximately the HSV cone using a much smoother
transformation.
"""
def from_rgb(self, imgs):
r, g, b = imgs.permute(1, 0, 2, 3)
x = r * np.sqrt(2) / 3 - g / (np.sqrt(2) * 3) - b / (np.sqrt(2) * 3)
y = g / np.sqrt(6) - b / np.sqrt(6)
z, _ = imgs.max(1)
return torch.stack([z, x + 0.5, y + 0.5], 1)
def to_rgb(self, imgs):
z, xp, yp = imgs.permute(1, 0, 2, 3)
x, y = xp - 0.5, yp - 0.5
rp = float(np.sqrt(2)) * x
gp = -x / np.sqrt(2) + y * np.sqrt(3 / 2)
bp = -x / np.sqrt(2) - y * np.sqrt(3 / 2)
delta = z - torch.max(torch.stack([rp, gp, bp], 1), 1)[0]
r, g, b = rp + delta, gp + delta, bp + delta
return torch.stack([r, g, b], 1).clamp(0, 1)
class HSVConeColorSpace(ColorSpace):
"""
Converts from RGB to the HSV "cone", where (x, y, z) =
(s * v cos h, s * v sin h, v). Note that this cone is then squashed to fit
in [0, 1]^3 by letting (x', y', z') = ((x + 1) / 2, (y + 1) / 2, z).
WARNING: has a very complex derivative, not very useful in practice
"""
def from_rgb(self, imgs):
r, g, b = imgs.permute(1, 0, 2, 3)
mx, argmx = imgs.max(1)
mn, _ = imgs.min(1)
chroma = mx - mn
eps = 1e-10
h_max_r = math.pi / 3 * (g - b) / (chroma + eps)
h_max_g = math.pi / 3 * (b - r) / (chroma + eps) + math.pi * 2 / 3
h_max_b = math.pi / 3 * (r - g) / (chroma + eps) + math.pi * 4 / 3
h = (((argmx == 0) & (chroma != 0)).float() * h_max_r
+ ((argmx == 1) & (chroma != 0)).float() * h_max_g
+ ((argmx == 2) & (chroma != 0)).float() * h_max_b)
x = torch.cos(h) * chroma
y = torch.sin(h) * chroma
z = mx
return torch.stack([(x + 1) / 2, (y + 1) / 2, z], 1)
def _to_rgb_part(self, h, chroma, v, n):
"""
Implements the function f(n) defined here:
https://en.wikipedia.org/wiki/HSL_and_HSV#Alternative_HSV_to_RGB
"""
k = (n + h * math.pi / 3) % 6
return v - chroma * torch.min(k, 4 - k).clamp(0, 1)
def to_rgb(self, imgs):
xp, yp, z = imgs.permute(1, 0, 2, 3)
x, y = xp * 2 - 1, yp * 2 - 1
# prevent NaN gradients when calculating atan2
x_nonzero = (1 - 2 * (torch.sign(x) == -1).float()) * (torch.abs(x) + 1e-10)
h = torch.atan2(y, x_nonzero)
v = z.clamp(0, 1)
chroma = torch.min(torch.sqrt(x ** 2 + y ** 2 + 1e-10), v)
r = self._to_rgb_part(h, chroma, v, 5)
g = self._to_rgb_part(h, chroma, v, 3)
b = self._to_rgb_part(h, chroma, v, 1)
return torch.stack([r, g, b], 1).clamp(0, 1)
class CIEXYZColorSpace(ColorSpace):
"""
The 1931 CIE XYZ color space (assuming input is in sRGB).
Warning: may have values outside [0, 1] range. Should only be used in
the process of converting to/from other color spaces.
"""
def from_rgb(self, imgs):
# apply gamma correction
small_values_mask = (imgs < 0.04045).float()
imgs_corrected = (
(imgs / 12.92) * small_values_mask +
((imgs + 0.055) / 1.055) ** 2.4 * (1 - small_values_mask)
)
# linear transformation to XYZ
r, g, b = imgs_corrected.permute(1, 0, 2, 3)
x = 0.4124 * r + 0.3576 * g + 0.1805 * b
y = 0.2126 * r + 0.7152 * g + 0.0722 * b
z = 0.0193 * r + 0.1192 * g + 0.9504 * b
return torch.stack([x, y, z], 1)
def to_rgb(self, imgs):
# linear transformation
x, y, z = imgs.permute(1, 0, 2, 3)
r = 3.2406 * x - 1.5372 * y - 0.4986 * z
g = -0.9689 * x + 1.8758 * y + 0.0415 * z
b = 0.0557 * x - 0.2040 * y + 1.0570 * z
imgs = torch.stack([r, g, b], 1)
# apply gamma correction
small_values_mask = (imgs < 0.0031308).float()
imgs_clamped = imgs.clamp(min=1e-10) # prevent NaN gradients
imgs_corrected = (
(12.92 * imgs) * small_values_mask +
(1.055 * imgs_clamped ** (1 / 2.4) - 0.055) *
(1 - small_values_mask)
)
return imgs_corrected
class CIELUVColorSpace(ColorSpace):
"""
Converts to the 1976 CIE L*u*v* color space.
"""
def __init__(self, up_white=0.1978, vp_white=0.4683, y_white=1,
eps=1e-10):
self.xyz_cspace = CIEXYZColorSpace()
self.up_white = up_white
self.vp_white = vp_white
self.y_white = y_white
self.eps = eps
def from_rgb(self, imgs):
x, y, z = self.xyz_cspace.from_rgb(imgs).permute(1, 0, 2, 3)
# calculate u' and v'
denom = x + 15 * y + 3 * z + self.eps
up = 4 * x / denom
vp = 9 * y / denom
# calculate L*, u*, and v*
small_values_mask = (y / self.y_white < (6 / 29) ** 3).float()
y_clamped = y.clamp(min=self.eps) # prevent NaN gradients
L = (
((29 / 3) ** 3 * y / self.y_white) * small_values_mask +
(116 * (y_clamped / self.y_white) ** (1 / 3) - 16) *
(1 - small_values_mask)
)
u = 13 * L * (up - self.up_white)
v = 13 * L * (vp - self.vp_white)
return torch.stack([L / 100, (u + 100) / 200, (v + 100) / 200], 1)
def to_rgb(self, imgs):
L = imgs[:, 0, :, :] * 100
u = imgs[:, 1, :, :] * 200 - 100
v = imgs[:, 2, :, :] * 200 - 100
up = u / (13 * L + self.eps) + self.up_white
vp = v / (13 * L + self.eps) + self.vp_white
small_values_mask = (L <= 8).float()
y = (
(self.y_white * L * (3 / 29) ** 3) * small_values_mask +
(self.y_white * ((L + 16) / 116) ** 3) * (1 - small_values_mask)
)
denom = 4 * vp + self.eps
x = y * 9 * up / denom
z = y * (12 - 3 * up - 20 * vp) / denom
return self.xyz_cspace.to_rgb(
torch.stack([x, y, z], 1).clamp(0, 1.1)).clamp(0, 1)
| 8,620 | 30.578755 | 85 | py |
DiffPure | DiffPure-master/stadv_eot/recoloradv/mister_ed/adversarial_training.py | # ---------------------------------------------------------------
# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# This file has been modified from recoloradv.
#
# Source:
# https://github.com/cassidylaidlaw/ReColorAdv/blob/master/recoloradv/mister_ed/adversarial_training.py
#
# The license for the original version of this file can be
# found in the `recoloradv` directory (LICENSE_RECOLORADV).
# The modifications to this file are subject to the same license.
# ---------------------------------------------------------------
""" Contains training code for adversarial training """
from __future__ import print_function
import torch
import torch.cuda as cuda
import torch.optim as optim
import torch.nn as nn
from torch.autograd import Variable
import random
from .utils import pytorch_utils as utils, checkpoints
##############################################################################
# #
# ATTACK PARAMETERS OBJECT #
# #
##############################################################################
class AdversarialAttackParameters(object):
""" Wrapper to store an adversarial attack object as well as some extra
parameters for how to use it in training
"""
def __init__(self, adv_attack_obj, proportion_attacked=1.0,
attack_specific_params=None):
""" Stores params for how to use adversarial attacks in training
ARGS:
adv_attack_obj : AdversarialAttack subclass -
thing that actually does the attack
proportion_attacked: float between [0.0, 1.0] - what proportion of
the minibatch we build adv examples for
attack_specific_params: possibly None dict, but possibly dict with
specific parameters for attacks
"""
self.adv_attack_obj = adv_attack_obj
self.proportion_attacked = proportion_attacked
attack_specific_params = attack_specific_params or {}
self.attack_specific_params = attack_specific_params
self.attack_kwargs = attack_specific_params.get('attack_kwargs', {})
def set_gpu(self, use_gpu):
""" Propagates changes of the 'use_gpu' parameter down to the attack
ARGS:
use_gpu : bool - if True, the attack uses the GPU, ow it doesn't
RETURNS:
None
"""
self.adv_attack_obj.use_gpu = use_gpu
def attack(self, inputs, labels):
""" Builds some adversarial examples given real inputs and labels
ARGS:
inputs : torch.Tensor (NxCxHxW) - tensor with examples needed
labels : torch.Tensor (N) - tensor with the examples needed
RETURNS:
some sample of (self.proportion_attacked * N ) examples that are
adversarial, and the corresponding NONADVERSARIAL LABELS
output is a tuple with three tensors:
(adv_examples, pre_adv_labels, selected_idxs, coupled )
adv_examples: Tensor with shape (N'xCxHxW) [the perturbed outputs]
pre_adv_labels: Tensor with shape (N') [original labels]
selected_idxs : Tensor with shape (N') [idxs selected]
adv_inputs : Tensor with shape (N') [examples used to make advs]
perturbation: Adversarial Perturbation Object
"""
num_elements = inputs.shape[0]
selected_idxs = sorted(random.sample(list(range(num_elements)),
int(self.proportion_attacked * num_elements)))
selected_idxs = inputs.new(selected_idxs).long()
if selected_idxs.numel() == 0:
return (None, None, None)
adv_inputs = Variable(inputs.index_select(0, selected_idxs))
pre_adv_labels = labels.index_select(0, selected_idxs)
perturbation = self.adv_attack_obj.attack(adv_inputs.data,
pre_adv_labels,
**self.attack_kwargs)
adv_examples = perturbation(adv_inputs)
return (adv_examples, pre_adv_labels, selected_idxs, adv_inputs,
perturbation)
def eval(self, ground_inputs, adv_inputs, labels, idxs, topk=1):
""" Outputs the accuracy of the adversarial examples
NOTE: notice the difference between N and N' in the argument
ARGS:
ground_inputs: Variable (NxCxHxW) - examples before we did
adversarial perturbation. Vals in [0, 1] range
adversarials: Variable (N'xCxHxW) - examples after we did
adversarial perturbation. Should be same shape and
in same order as ground_truth
labels: Variable (longTensor N) - correct labels of classification
output
idxs: Variable (longtensor N') - indices of ground_inputs/labels
used for adversarials.
RETURNS:
tuple of (% of correctly classified original examples,
% of correctly classified adversarial examples)
"""
selected_grounds = ground_inputs.index_select(0, idxs)
selected_labels = labels.index_select(0, idxs)
return self.adv_attack_obj.eval(selected_grounds, adv_inputs,
selected_labels, topk=topk)
def eval_attack_only(self, adv_inputs, labels, topk=1):
""" Outputs the accuracy of the adv_inputs only
ARGS:
adv_inputs: Variable NxCxHxW - examples after we did adversarial
perturbation
labels: Variable (longtensor N) - correct labels of classification
output
topk: int - criterion for 'correct' classification
RETURNS:
(int) number of correctly classified examples
"""
return self.adv_attack_obj.eval_attack_only(adv_inputs, labels,
topk=topk)
##############################################################################
# #
# TRAINING OBJECT #
# #
##############################################################################
class AdversarialTraining(object):
""" Wrapper for training of a NN with adversarial examples cooked in
"""
def __init__(self, classifier_net, normalizer,
experiment_name, architecture_name,
manual_gpu=None):
"""
ARGS:
classifier_net : nn.Module subclass - instance of neural net to classify
images. Can have already be trained, or not
normalizer : DifferentiableNormalize - object to convert to zero-mean
unit-variance domain
experiment_name : String - human-readable name of the 'trained_model'
(this is helpful for identifying checkpoints later)
manual_gpu : None or bool - if not None is a manual override of whether
or not to use the GPU. If left None, we use the GPU if we
can
ON NOMENCLATURE:
Depending on verbosity levels, training checkpoints are saved after
some training epochs. These are saved as
'<experiment_name>/<architecture_name>/<epoch>.path.tar'
Best practice is to keep architecture_name consistent across
adversarially trained models built off the same architecture and having
a descriptive experiment_name for each training instance
"""
self.classifier_net = classifier_net
self.normalizer = normalizer
self.experiment_name = experiment_name
self.architecture_name = architecture_name
if manual_gpu is not None:
self.use_gpu = manual_gpu
else:
self.use_gpu = utils.use_gpu()
self.verbosity_level = None
self.verbosity_minibatch = None
self.verbosity_adv = None
self.verbosity_epoch = None
self.logger = utils.TrainingLogger()
self.log_level = None
self.log_minibatch = None
self.log_adv = None
self.log_epoch = None
def reset_logger(self):
""" Clears the self.logger instance - useful occasionally """
self.logger = utils.TrainingLogger()
def set_verbosity_loglevel(self, level,
verbosity_or_loglevel='verbosity'):
""" Sets the verbosity or loglevel for training.
Is called in .train method so this method doesn't need to be
explicitly called.
Verbosity is mapped from a string to a comparable int 'level'.
<val>_level : int - comparable value of verbosity
<val>_minibatch: int - we do a printout every this many
minibatches
<val>_adv: int - we evaluate the efficacy of our attack every
this many minibatches
<val>_epoch: int - we printout/log and checkpoint every this many
epochs
ARGS:
level : string ['low', 'medium', 'high', 'snoop'],
varying levels of verbosity/logging in increasing order
RETURNS: None
"""
assert level in ['low', 'medium', 'high', 'snoop']
assert verbosity_or_loglevel in ['verbosity', 'loglevel']
setattr(self, verbosity_or_loglevel, level)
_level = {'low': 0,
'medium': 1,
'high': 2,
'snoop': 420}[level]
setattr(self, verbosity_or_loglevel + '_level', _level)
_minibatch = {'medium': 2000,
'high': 100,
'snoop': 1}.get(level)
setattr(self, verbosity_or_loglevel + '_minibatch', _minibatch)
_adv = {'medium': 2000,
'high': 100,
'snoop': 1}.get(level)
setattr(self, verbosity_or_loglevel + '_adv', _minibatch)
_epoch = {'low': 100,
'medium': 10,
'high': 1,
'snoop': 1}.get(level)
setattr(self, verbosity_or_loglevel + '_epoch', _epoch)
def _attack_subroutine(self, attack_parameters, inputs, labels,
epoch_num, minibatch_num, adv_saver,
logger):
""" Subroutine to run the specified attack on a minibatch and append
the results to inputs/labels.
NOTE: THIS DOES NOT MUTATE inputs/labels !!!!
ARGS:
attack_parameters: {k: AdversarialAttackParameters} (or None) -
if not None, contains info on how to do adv
attacks. If None, we don't train adversarially
inputs : Tensor (NxCxHxW) - minibatch of data we build adversarial
examples for
labels : Tensor (longtensor N) - minibatch of labels
epoch_num : int - number of which epoch we're working on.
Is helpful for printing
minibatch_num : int - number of which minibatch we're working on.
Is helpful for printing
adv_saver : None or checkpoints.CustomDataSaver -
if not None, we save the adversarial images for later
use, else we don't save them.
logger : utils.TrainingLogger instance - logger instance to keep
track of logging data if we need data for this instance
RETURNS:
(inputs, labels, adv_inputs, coupled_inputs)
where inputs = <arg inputs> ++ adv_inputs
labels is original labels
adv_inputs is the (Variable) adversarial examples generated,
coupled_inputs is the (Variable) inputs used to generate the
adversarial examples (useful for when we don't
augment 1:1).
"""
if attack_parameters is None:
return inputs, labels, None, None
assert isinstance(attack_parameters, dict)
adv_inputs_total, adv_labels_total, coupled_inputs = [], [], []
for (key, param) in attack_parameters.items():
adv_data = param.attack(inputs, labels)
adv_inputs, adv_labels, adv_idxs, og_adv_inputs, _ = adv_data
needs_print = (self.verbosity_level >= 1 and
minibatch_num % self.verbosity_adv == self.verbosity_adv - 1)
needs_log = (self.loglevel_level >= 1 and
minibatch_num % self.loglevel_adv == self.loglevel_adv - 1)
if needs_print or needs_log:
accuracy = param.eval(inputs, adv_inputs, labels, adv_idxs)
if needs_print:
print('[%d, %5d] accuracy: (%.3f, %.3f)' %
(epoch_num, minibatch_num + 1, accuracy[1], accuracy[0]))
if needs_log:
logger.log(key, epoch_num, minibatch_num + 1,
(accuracy[1], accuracy[0]))
if adv_saver is not None: # Save the adversarial examples
adv_saver.save_minibatch(adv_inputs, adv_labels)
adv_inputs_total.append(adv_inputs)
adv_labels_total.append(adv_labels)
coupled_inputs.append(og_adv_inputs)
inputs = torch.cat([inputs] + [_.data for _ in adv_inputs_total], dim=0)
labels = torch.cat([labels] + adv_labels_total, dim=0)
coupled = torch.cat(coupled_inputs, dim=0)
return inputs, labels, torch.cat(adv_inputs_total, dim=0), coupled
def train(self, data_loader, num_epochs, train_loss,
optimizer=None, attack_parameters=None,
verbosity='medium', loglevel='medium', logger=None,
starting_epoch=0, adversarial_save_dir=None,
regularize_adv_scale=None):
""" Modifies the NN weights of self.classifier_net by training with
the specified parameters s
ARGS:
data_loader: torch.utils.data.DataLoader OR
checkpoints.CustomDataLoader - object that loads the
data
num_epoch: int - number of epochs to train on
train_loss: ???? - TBD
optimizer: torch.Optimizer subclass - defaults to Adam with some
decent default params. Pass this in as an actual argument
to do anything different
attack_parameters: AdversarialAttackParameters obj | None |
{key: AdversarialAttackParameters} -
if not None, is either an object or dict of
objects containing names and info on how to do
adv attacks. If None, we don't train
adversarially
verbosity : string - must be 'low', 'medium', 'high', which
describes how much to print
loglevel : string - must be 'low', 'medium', 'high', which
describes how much to log
logger : if not None, is a utils.TrainingLogger instance. Otherwise
we use this instance's self.logger object to log
starting_epoch : int - which epoch number we start on. Is useful
for correct labeling of checkpoints and figuring
out how many epochs we actually need to run for
(i.e., num_epochs - starting_epoch)
adversarial_save_dir: string or None - if not None is the name of
the directory we save adversarial images to.
If None, we don't save adversarial images
regularize_adv_scale : float > 0 or None - if not None we do L1 loss
between the logits of the adv examples and
the inputs used to generate them. This is the
scale constant of that loss
stdout_prints: bool - if True we print out using stdout so we don't
spam logs like crazy
RETURNS:
None, but modifies the classifier_net's weights
"""
######################################################################
# Setup/ input validations #
######################################################################
self.classifier_net.train() # in training mode
assert isinstance(num_epochs, int)
if attack_parameters is not None:
if not isinstance(attack_parameters, dict):
attack_parameters = {'attack': attack_parameters}
# assert that the adv attacker uses the NN that's being trained
for param in attack_parameters.values():
assert (param.adv_attack_obj.classifier_net ==
self.classifier_net)
assert not (self.use_gpu and not cuda.is_available())
if self.use_gpu:
self.classifier_net.cuda()
if attack_parameters is not None:
for param in attack_parameters.values():
param.set_gpu(self.use_gpu)
# Verbosity parameters
assert verbosity in ['low', 'medium', 'high', 'snoop', None]
self.set_verbosity_loglevel(verbosity,
verbosity_or_loglevel='verbosity')
verbosity_level = self.verbosity_level
verbosity_minibatch = self.verbosity_minibatch
verbosity_epoch = self.verbosity_epoch
# Loglevel parameters and logger initialization
assert loglevel in ['low', 'medium', 'high', 'snoop', None]
if logger is None:
logger = self.logger
if logger.data_count() > 0:
print("WARNING: LOGGER IS NOT EMPTY! BE CAREFUL!")
logger.add_series('training_loss')
for key in (attack_parameters or {}).keys():
logger.add_series(key)
self.set_verbosity_loglevel(loglevel, verbosity_or_loglevel='loglevel')
loglevel_level = self.loglevel_level
loglevel_minibatch = self.loglevel_minibatch
loglevel_epoch = self.loglevel_epoch
# Adversarial image saver:
adv_saver = None
if adversarial_save_dir is not None and attack_parameters is not None:
adv_saver = checkpoints.CustomDataSaver(adversarial_save_dir)
# setup loss fxn, optimizer
optimizer = optimizer or optim.Adam(self.classifier_net.parameters(),
lr=0.001)
# setup regularize adv object
if regularize_adv_scale is not None:
regularize_adv_criterion = nn.L1Loss()
######################################################################
# Training loop #
######################################################################
for epoch in range(starting_epoch + 1, num_epochs + 1):
running_loss_print, running_loss_print_mb = 0.0, 0
running_loss_log, running_loss_log_mb = 0.0, 0
for i, data in enumerate(data_loader, 0):
inputs, labels = data
if self.use_gpu:
inputs = inputs.cuda()
labels = labels.cuda()
# Build adversarial examples
attack_out = self._attack_subroutine(attack_parameters,
inputs, labels,
epoch, i, adv_saver,
logger)
inputs, labels, adv_examples, adv_inputs = attack_out
# Now proceed with standard training
self.normalizer.differentiable_call()
self.classifier_net.train()
inputs, labels = Variable(inputs), Variable(labels)
optimizer.zero_grad()
# forward step
outputs = self.classifier_net.forward(self.normalizer(inputs))
loss = train_loss.forward(outputs, labels)
if regularize_adv_scale is not None:
# BE SURE TO 'DETACH' THE ADV_INPUTS!!!
reg_adv_loss = regularize_adv_criterion(adv_examples,
Variable(adv_inputs.data))
print(float(loss), regularize_adv_scale * float(reg_adv_loss))
loss = loss + regularize_adv_scale * reg_adv_loss
# backward step
loss.backward()
optimizer.step()
# print things
running_loss_print += float(loss.data)
running_loss_print_mb += 1
if (verbosity_level >= 1 and
i % verbosity_minibatch == verbosity_minibatch - 1):
print('[%d, %5d] loss: %.6f' %
(epoch, i + 1, running_loss_print /
float(running_loss_print_mb)))
running_loss_print = 0.0
running_loss_print_mb = 0
# log things
running_loss_log += float(loss.data)
running_loss_log_mb += 1
if (loglevel_level >= 1 and
i % loglevel_minibatch == loglevel_minibatch - 1):
logger.log('training_loss', epoch, i + 1,
running_loss_log / float(running_loss_log_mb))
running_loss_log = 0.0
running_loss_log_mb = 0
# end_of_epoch
if epoch % verbosity_epoch == 0:
print("COMPLETED EPOCH %04d... checkpointing here" % epoch)
checkpoints.save_state_dict(self.experiment_name,
self.architecture_name,
epoch, self.classifier_net,
k_highest=3)
if verbosity_level >= 1:
print('Finished Training')
return logger
def train_from_checkpoint(self, data_loader, num_epochs, loss_fxn,
optimizer=None, attack_parameters=None,
verbosity='medium',
starting_epoch='max',
adversarial_save_dir=None):
""" Resumes training from a saved checkpoint with the same architecture.
i.e. loads weights from specified checkpoint, figures out which
epoch we checkpointed on and then continues training until
we reach num_epochs epochs
ARGS:
same as in train
starting_epoch: 'max' or int - which epoch we start training from.
'max' means the highest epoch we can find,
an int means a specified int epoch exactly.
RETURNS:
None
"""
######################################################################
# Checkpoint handling block #
######################################################################
# which epoch to load
valid_epochs = checkpoints.list_saved_epochs(self.experiment_name,
self.architecture_name)
assert valid_epochs != []
if starting_epoch == 'max':
epoch = max(valid_epochs)
else:
assert starting_epoch in valid_epochs
epoch = starting_epoch
# modify the classifer to use these weights
self.classifier_net = checkpoints.load_state_dict(self.experiment_name,
self.architecture_name,
epoch,
self.classifier_net)
######################################################################
# Training block #
######################################################################
self.train(data_loader, num_epochs, loss_fxn,
optimizer=optimizer,
attack_parameters=attack_parameters,
verbosity=verbosity,
starting_epoch=epoch,
adversarial_save_dir=adversarial_save_dir)
| 25,356 | 45.019964 | 103 | py |
DiffPure | DiffPure-master/stadv_eot/recoloradv/mister_ed/adversarial_attacks.py | # ---------------------------------------------------------------
# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# This file has been modified from recoloradv.
#
# Source:
# https://github.com/cassidylaidlaw/ReColorAdv/blob/master/recoloradv/mister_ed/adversarial_attacks.py
#
# The license for the original version of this file can be
# found in the `recoloradv` directory (LICENSE_RECOLORADV).
# The modifications to this file are subject to the same license.
# ---------------------------------------------------------------
""" Holds the various attacks we can do """
from __future__ import print_function
from six import string_types
import torch
from torch.autograd import Variable
from torch import optim
from .utils import pytorch_utils as utils
from . import loss_functions as lf
MAXFLOAT = 1e20
###############################################################################
# #
# PARENT CLASS FOR ADVERSARIAL ATTACKS #
# #
###############################################################################
class AdversarialAttack(object):
""" Wrapper for adversarial attacks. Is helpful for when subsidiary methods
are needed.
"""
def __init__(self, classifier_net, normalizer, threat_model,
manual_gpu=None):
""" Initializes things to hold to perform a single batch of
adversarial attacks
ARGS:
classifier_net : nn.Module subclass - neural net that is the
classifier we're attacking
normalizer : DifferentiableNormalize object - object to convert
input data to mean-zero, unit-var examples
threat_model : ThreatModel object - object that allows us to create
per-minibatch adversarial examples
manual_gpu : None or boolean - if not None, we override the
environment variable 'MISTER_ED_GPU' for how we use
the GPU in this object
"""
self.classifier_net = classifier_net
self.normalizer = normalizer or utils.IdentityNormalize()
if manual_gpu is not None:
self.use_gpu = manual_gpu
else:
self.use_gpu = utils.use_gpu()
self.validator = lambda *args: None
self.threat_model = threat_model
@property
def _dtype(self):
return torch.cuda.FloatTensor if self.use_gpu else torch.FloatTensor
def setup(self):
self.classifier_net.eval()
self.normalizer.differentiable_call()
def eval(self, ground_examples, adversarials, labels, topk=1):
""" Evaluates how good the adversarial examples are
ARGS:
ground_truths: Variable (NxCxHxW) - examples before we did
adversarial perturbation. Vals in [0, 1] range
adversarials: Variable (NxCxHxW) - examples after we did
adversarial perturbation. Should be same shape and
in same order as ground_truth
labels: Variable (longTensor N) - correct labels of classification
output
RETURNS:
tuple of (% of correctly classified original examples,
% of correctly classified adversarial examples)
"""
normed_ground = self.normalizer.forward(ground_examples)
ground_output = self.classifier_net.forward(normed_ground)
normed_advs = self.normalizer.forward(adversarials)
adv_output = self.classifier_net.forward(normed_advs)
start_prec = utils.accuracy(ground_output.data, labels.data,
topk=(topk,))
adv_prec = utils.accuracy(adv_output.data, labels.data,
topk=(topk,))
return float(start_prec[0]), float(adv_prec[0])
def eval_attack_only(self, adversarials, labels, topk=1):
""" Outputs the accuracy of the adv_inputs only
ARGS:
adv_inputs: Variable NxCxHxW - examples after we did adversarial
perturbation
labels: Variable (longtensor N) - correct labels of classification
output
topk: int - criterion for 'correct' classification
RETURNS:
(int) number of correctly classified examples
"""
normed_advs = self.normalizer.forward(adversarials)
adv_output = self.classifier_net.forward(normed_advs)
return utils.accuracy_int(adv_output, labels, topk=topk)
def print_eval_str(self, ground_examples, adversarials, labels, topk=1):
""" Prints how good this adversarial attack is
(explicitly prints out %CorrectlyClassified(ground_examples)
vs %CorrectlyClassified(adversarials)
ARGS:
ground_truths: Variable (NxCxHxW) - examples before we did
adversarial perturbation. Vals in [0, 1] range
adversarials: Variable (NxCxHxW) - examples after we did
adversarial perturbation. Should be same shape and
in same order as ground_truth
labels: Variable (longTensor N) - correct labels of classification
output
RETURNS:
None, prints some stuff though
"""
og, adv = self.eval(ground_examples, adversarials, labels, topk=topk)
print("Went from %s correct to %s correct" % (og, adv))
def validation_loop(self, examples, labels, iter_no=None):
""" Prints out validation values interim for use in iterative techniques
ARGS:
new_examples: Variable (NxCxHxW) - [0.0, 1.0] images to be
classified and compared against labels
labels: Variable (longTensor
N) - correct labels for indices of
examples
iter_no: String - an extra thing for prettier prints
RETURNS:
None
"""
normed_input = self.normalizer.forward(examples)
new_output = self.classifier_net.forward(normed_input)
new_prec = utils.accuracy(new_output.data, labels.data, topk=(1,))
print_str = ""
if isinstance(iter_no, int):
print_str += "(iteration %02d): " % iter_no
elif isinstance(iter_no, string_types):
print_str += "(%s): " % iter_no
else:
pass
print_str += " %s correct" % float(new_prec[0])
print(print_str)
##############################################################################
# #
# Fast Gradient Sign Method (FGSM) #
# #
##############################################################################
class FGSM(AdversarialAttack):
def __init__(self, classifier_net, normalizer, threat_model, loss_fxn,
manual_gpu=None):
super(FGSM, self).__init__(classifier_net, normalizer, threat_model,
manual_gpu=manual_gpu)
self.loss_fxn = loss_fxn
def attack(self, examples, labels, step_size=0.05, verbose=True):
""" Builds FGSM examples for the given examples with l_inf bound
ARGS:
classifier: Pytorch NN
examples: Nxcxwxh tensor for N examples. NOT NORMALIZED (i.e. all
vals are between 0.0 and 1.0 )
labels: single-dimension tensor with labels of examples (in same
order)
step_size: float - how much we nudge each parameter along the
signs of its gradient
normalizer: DifferentiableNormalize object to prep objects into
classifier
evaluate: boolean, if True will validation results
loss_fxn: RegularizedLoss object - partially applied loss fxn that
takes [0.0, 1.0] image Variables and labels and outputs
a scalar loss variable. Also has a zero_grad method
RETURNS:
AdversarialPerturbation object with correct parameters.
Calling perturbation() gets Variable of output and
calling perturbation().data gets tensor of output
"""
self.classifier_net.eval() # ALWAYS EVAL FOR BUILDING ADV EXAMPLES
perturbation = self.threat_model(examples)
var_examples = Variable(examples, requires_grad=True)
var_labels = Variable(labels, requires_grad=False)
######################################################################
# Build adversarial examples #
######################################################################
# Fix the 'reference' images for the loss function
self.loss_fxn.setup_attack_batch(var_examples)
# take gradients
loss = self.loss_fxn.forward(perturbation(var_examples), var_labels,
perturbation=perturbation)
torch.autograd.backward(loss)
# add adversarial noise to each parameter
update_fxn = lambda grad_data: step_size * torch.sign(grad_data)
perturbation.update_params(update_fxn)
if verbose:
self.validation_loop(perturbation(var_examples), var_labels,
iter_no='Post FGSM')
# output tensor with the data
self.loss_fxn.cleanup_attack_batch()
perturbation.attach_originals(examples)
return perturbation
##############################################################################
# #
# PGD/FGSM^k/BIM #
# #
##############################################################################
# This goes by a lot of different names in the literature
# The key idea here is that we take many small steps of FGSM
# I'll call it PGD though
class PGD(AdversarialAttack):
def __init__(self, classifier_net, normalizer, threat_model, loss_fxn,
manual_gpu=None):
super(PGD, self).__init__(classifier_net, normalizer, threat_model,
manual_gpu=manual_gpu)
self.loss_fxn = loss_fxn # WE MAXIMIZE THIS!!!
def attack(self, examples, labels, step_size=1.0 / 255.0,
num_iterations=20, random_init=False, signed=True,
optimizer=None, optimizer_kwargs=None,
loss_convergence=0.999, verbose=True,
keep_best=True, eot_iter=1):
""" Builds PGD examples for the given examples with l_inf bound and
given step size. Is almost identical to the BIM attack, except
we take steps that are proportional to gradient value instead of
just their sign.
ARGS:
examples: NxCxHxW tensor - for N examples, is NOT NORMALIZED
(i.e., all values are in between 0.0 and 1.0)
labels: N longTensor - single dimension tensor with labels of
examples (in same order as examples)
l_inf_bound : float - how much we're allowed to perturb each pixel
(relative to the 0.0, 1.0 range)
step_size : float - how much of a step we take each iteration
num_iterations: int or pair of ints - how many iterations we take.
If pair of ints, is of form (lo, hi), where we run
at least 'lo' iterations, at most 'hi' iterations
and we quit early if loss has stabilized.
random_init : bool - if True, we randomly pick a point in the
l-inf epsilon ball around each example
signed : bool - if True, each step is
adversarial = adversarial + sign(grad)
[this is the form that madry et al use]
if False, each step is
adversarial = adversarial + grad
keep_best : bool - if True, we keep track of the best adversarial
perturbations per example (in terms of maximal
loss) in the minibatch. The output is the best of
each of these then
RETURNS:
AdversarialPerturbation object with correct parameters.
Calling perturbation() gets Variable of output and
calling perturbation().data gets tensor of output
"""
######################################################################
# Setups and assertions #
######################################################################
self.classifier_net.eval()
if not verbose:
self.validator = lambda ex, label, iter_no: None
else:
self.validator = self.validation_loop
perturbation = self.threat_model(examples)
num_examples = examples.shape[0]
var_examples = Variable(examples, requires_grad=True)
var_labels = Variable(labels, requires_grad=False)
if isinstance(num_iterations, int):
min_iterations = num_iterations
max_iterations = num_iterations
elif isinstance(num_iterations, tuple):
min_iterations, max_iterations = num_iterations
best_perturbation = None
if keep_best:
best_loss_per_example = {i: None for i in range(num_examples)}
prev_loss = None
######################################################################
# Loop through iterations #
######################################################################
self.loss_fxn.setup_attack_batch(var_examples)
self.validator(var_examples, var_labels, iter_no="START")
# random initialization if necessary
if random_init:
perturbation.random_init()
self.validator(perturbation(var_examples), var_labels,
iter_no="RANDOM")
# Build optimizer techniques for both signed and unsigned methods
optimizer = optimizer or optim.Adam
if optimizer_kwargs is None:
optimizer_kwargs = {'lr': 0.0001}
optimizer = optimizer(perturbation.parameters(), **optimizer_kwargs)
update_fxn = lambda grad_data: -1 * step_size * torch.sign(grad_data)
param_list = list(perturbation.parameters())
assert len(param_list) == 1, len(param_list)
param = param_list[0]
print(f'inside PGD attack, eot_iter: {eot_iter}, max_iterations: {max_iterations}')
for iter_no in range(max_iterations):
perturbation.zero_grad()
grad = torch.zeros_like(param)
loss_per_example_ave = 0
for i in range(eot_iter):
loss_per_example = self.loss_fxn.forward(perturbation(var_examples), var_labels,
perturbation=perturbation,
output_per_example=keep_best)
loss_per_example_ave += loss_per_example.detach().clone()
loss = -1 * loss_per_example.sum()
loss.backward()
grad += param.grad.data.detach()
param.grad.data.zero_()
grad /= float(eot_iter)
loss_per_example_ave /= float(eot_iter)
assert len(param_list) == 1, len(param_list)
param.grad.data = grad.clone()
if signed:
perturbation.update_params(update_fxn)
else:
optimizer.step()
if keep_best:
mask_val = torch.zeros(num_examples, dtype=torch.uint8)
for i, el in enumerate(loss_per_example_ave):
this_best_loss = best_loss_per_example[i]
if this_best_loss is None or this_best_loss[1] < float(el):
mask_val[i] = 1
best_loss_per_example[i] = (iter_no, float(el))
if best_perturbation is None:
best_perturbation = self.threat_model(examples)
best_perturbation = perturbation.merge_perturbation(
best_perturbation,
mask_val)
self.validator((best_perturbation or perturbation)(var_examples),
var_labels, iter_no=iter_no)
# Stop early if loss didn't go down too much
if (iter_no >= min_iterations and
float(loss) >= loss_convergence * prev_loss):
if verbose:
print("Stopping early at %03d iterations" % iter_no)
break
prev_loss = float(loss)
perturbation.zero_grad()
self.loss_fxn.cleanup_attack_batch()
perturbation.attach_originals(examples)
return perturbation
##############################################################################
# #
# CARLINI WAGNER #
# #
##############################################################################
"""
General class of CW attacks: these aim to solve optim problems of the form
Adv(x) = argmin_{x'} D(x, x')
s.t. f(x) != f(x')
x' is a valid attack (e.g., meets LP bounds)
Which is typically relaxed to solving
Adv(x) = argmin_{x'} D(x, x') + lambda * L_adv(x')
where L_adv(x') is only nonpositive when f(x) != f(x').
Binary search is performed on a per-example basis to find the appropriate
lambda.
The distance function is backpropagated through in each bin search step, so it
needs to be differentiable. It does not need to be a true distance metric tho
"""
class CarliniWagner(AdversarialAttack):
def __init__(self, classifier_net, normalizer, threat_model,
distance_fxn, carlini_loss, manual_gpu=None):
""" This is a different init than the other style attacks because the
loss function is separated into two arguments here
ARGS:
classifier_net: standard attack arg
normalizer: standard attack arg
threat_model: standard attack arg
distance_fxn: lf.ReferenceRegularizer subclass (CLASS NOT INSTANCE)
- is a loss function
that stores originals so it can be used to create a
RegularizedLoss object with the carlini loss object
carlini_loss: lf.PartialLoss subclass (CLASS NOT INSTANCE) - is the
loss term that is
a function on images and labels that only
returns zero when the images are adversarial
"""
super(CarliniWagner, self).__init__(classifier_net, normalizer,
threat_model, manual_gpu=manual_gpu)
assert issubclass(distance_fxn, lf.ReferenceRegularizer)
assert issubclass(carlini_loss, lf.CWLossF6)
self.loss_classes = {'distance_fxn': distance_fxn,
'carlini_loss': carlini_loss}
def _construct_loss_fxn(self, initial_lambda, confidence):
""" Uses the distance_fxn and carlini_loss to create a loss function to
be optimized
ARGS:
initial_lambda : float - which lambda to use initially
in the regularization of the carlini loss
confidence : float - how great the difference in the logits must be
for the carlini_loss to be zero. Overwrites the
self.carlini_loss.kappa value
RETURNS:
RegularizedLoss OBJECT to be used as the loss for this optimization
"""
losses = {'distance_fxn': self.loss_classes['distance_fxn'](None,
use_gpu=self.use_gpu),
'carlini_loss': self.loss_classes['carlini_loss'](
self.classifier_net,
self.normalizer,
kappa=confidence)}
scalars = {'distance_fxn': 1.0,
'carlini_loss': initial_lambda}
return lf.RegularizedLoss(losses, scalars)
def _optimize_step(self, optimizer, perturbation, var_examples,
var_targets, var_scale, loss_fxn, targeted=False):
""" Does one step of optimization """
assert not targeted
optimizer.zero_grad()
loss = loss_fxn.forward(perturbation(var_examples), var_targets)
if torch.numel(loss) > 1:
loss = loss.sum()
loss.backward()
optimizer.step()
# return a loss 'average' to determine if we need to stop early
return loss.item()
def _batch_compare(self, example_logits, targets, confidence=0.0,
targeted=False):
""" Returns a list of indices of valid adversarial examples
ARGS:
example_logits: Variable/Tensor (Nx#Classes) - output logits for a
batch of images
targets: Variable/Tensor (N) - each element is a class index for the
target class for the i^th example.
confidence: float - how much the logits must differ by for an
attack to be considered valid
targeted: bool - if True, the 'targets' arg should be the targets
we want to hit. If False, 'targets' arg should be
the targets we do NOT want to hit
RETURNS:
Variable ByteTensor of length (N) on the same device as
example_logits/targets with 1's for successful adversaral examples,
0's for unsuccessful
"""
# check if the max val is the targets
target_vals = example_logits.gather(1, targets.view(-1, 1))
max_vals, max_idxs = torch.max(example_logits, 1)
max_eq_targets = torch.eq(targets, max_idxs)
# check margins between max and target_vals
if targeted:
max_2_vals, _ = example_logits.kthvalue(2, dim=1)
good_confidence = torch.gt(max_vals - confidence, max_2_vals)
one_hot_indices = max_eq_targets * good_confidence
else:
good_confidence = torch.gt(max_vals.view(-1, 1),
target_vals + confidence)
one_hot_indices = ((1 - max_eq_targets.data).view(-1, 1) *
good_confidence.data)
return one_hot_indices.squeeze()
# return [idx for idx, el in enumerate(one_hot_indices) if el[0] == 1]
@classmethod
def tweak_lambdas(cls, var_scale_lo, var_scale_hi, var_scale,
successful_mask):
""" Modifies the constant scaling that we keep to weight f_adv vs D(.)
in our loss function.
IF the attack was successful
THEN hi -> lambda
lambda -> (lambda + lo) /2
ELSE
lo -> lambda
lambda -> (lambda + hi) / 2
ARGS:
var_scale_lo : Variable (N) - variable that holds the running lower
bounds in our binary search
var_scale_hi: Variable (N) - variable that holds the running upper
bounds in our binary search
var_scale : Variable (N) - variable that holds the lambdas we
actually use
successful_mask : Variable (ByteTensor N) - mask that holds the
indices of the successful attacks
RETURNS:
(var_scale_lo, var_scale_hi, var_scale) but modified according to
the rule describe in the spec of this method
"""
prev_his = var_scale_hi.data
downweights = (var_scale_lo.data + var_scale.data) / 2.0
upweights = (var_scale_hi.data + var_scale.data) / 2.0
scale_hi = utils.fold_mask(var_scale.data, var_scale_hi.data,
successful_mask.data)
scale_lo = utils.fold_mask(var_scale_lo.data, var_scale.data,
successful_mask.data)
scale = utils.fold_mask(downweights, upweights,
successful_mask.data)
return (Variable(scale_lo), Variable(scale_hi), Variable(scale))
def attack(self, examples, labels, targets=None, initial_lambda=1.0,
num_bin_search_steps=10, num_optim_steps=1000,
confidence=0.0, verbose=True):
""" Performs Carlini Wagner attack on provided examples to make them
not get classified as the labels.
ARGS:
examples : Tensor (NxCxHxW) - input images to be made adversarial
labels : Tensor (N) - correct labels of the examples
initial_lambda : float - which lambda to use initially
in the regularization of the carlini loss
num_bin_search_steps : int - how many binary search steps we perform
to optimize the lambda
num_optim_steps : int - how many optimizer steps we perform during
each binary search step (we may stop early)
confidence : float - how great the difference in the logits must be
for the carlini_loss to be zero. Overwrites the
self.carlini_loss.kappa value
RETURNS:
AdversarialPerturbation object with correct parameters.
Calling perturbation() gets Variable of output and
calling perturbation().data gets tensor of output
calling perturbation(distances=True) returns a dict like
{}
"""
######################################################################
# First perform some setups #
######################################################################
if targets is not None:
raise NotImplementedError("Targeted attacks aren't built yet")
if self.use_gpu:
examples = examples.cuda()
labels = labels.cuda()
self.classifier_net.eval() # ALWAYS EVAL FOR BUILDING ADV EXAMPLES
var_examples = Variable(examples, requires_grad=False)
var_labels = Variable(labels, requires_grad=False)
loss_fxn = self._construct_loss_fxn(initial_lambda, confidence)
loss_fxn.setup_attack_batch(var_examples)
distance_fxn = loss_fxn.losses['distance_fxn']
num_examples = examples.shape[0]
best_results = {'best_dist': torch.ones(num_examples) \
.type(examples.type()) \
* MAXFLOAT,
'best_perturbation': self.threat_model(examples)}
######################################################################
# Now start the binary search #
######################################################################
var_scale_lo = Variable(torch.zeros(num_examples) \
.type(self._dtype).squeeze())
var_scale = Variable(torch.ones(num_examples, 1).type(self._dtype) *
initial_lambda).squeeze()
var_scale_hi = Variable(torch.ones(num_examples).type(self._dtype)
* 128).squeeze() # HARDCODED UPPER LIMIT
for bin_search_step in range(num_bin_search_steps):
perturbation = self.threat_model(examples)
##################################################################
# Optimize with a given scale constant #
##################################################################
if verbose:
print("Starting binary_search_step %02d..." % bin_search_step)
prev_loss = MAXFLOAT
optimizer = optim.Adam(perturbation.parameters(), lr=0.001)
for optim_step in range(num_optim_steps):
if verbose and optim_step > 0 and optim_step % 25 == 0:
print("Optim search: %s, Loss: %s" %
(optim_step, prev_loss))
loss_sum = self._optimize_step(optimizer, perturbation,
var_examples, var_labels,
var_scale, loss_fxn)
if loss_sum + 1e-10 > prev_loss * 0.99999 and optim_step >= 100:
if verbose:
print(("...stopping early on binary_search_step %02d "
" after %03d iterations") % (bin_search_step,
optim_step))
break
prev_loss = loss_sum
# End inner optimize loop
################################################################
# Update with results from optimization #
################################################################
# We only keep this round's perturbations if two things occur:
# 1) the perturbation fools the classifier
# 2) the perturbation is closer to original than the best-so-far
bin_search_perts = perturbation(var_examples)
bin_search_out = self.classifier_net.forward(bin_search_perts)
successful_attack_idxs = self._batch_compare(bin_search_out,
var_labels)
batch_dists = distance_fxn.forward(bin_search_perts).data
successful_dist_idxs = batch_dists < best_results['best_dist']
successful_dist_idxs = successful_dist_idxs
successful_mask = successful_attack_idxs * successful_dist_idxs
# And then generate a new 'best distance' and 'best perturbation'
best_results['best_dist'] = utils.fold_mask(batch_dists,
best_results['best_dist'],
successful_mask)
best_results['best_perturbation'] = \
perturbation.merge_perturbation(
best_results['best_perturbation'],
successful_mask)
# And then adjust the scale variables (lambdas)
new_scales = self.tweak_lambdas(var_scale_lo, var_scale_hi,
var_scale,
Variable(successful_mask))
var_scale_lo, var_scale_hi, var_scale = new_scales
# End binary search loop
if verbose:
num_successful = len([_ for _ in best_results['best_dist']
if _ < MAXFLOAT])
print("\n Ending attack")
print("Successful attacks for %03d/%03d examples in CONTINUOUS" % \
(num_successful, num_examples))
loss_fxn.cleanup_attack_batch()
perturbation.attach_originals(examples)
perturbation.attach_attr('distances', best_results['best_dist'])
return perturbation
| 32,417 | 44.659155 | 102 | py |
DiffPure | DiffPure-master/stadv_eot/recoloradv/mister_ed/loss_functions.py | # ---------------------------------------------------------------
# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# This file has been modified from recoloradv.
#
# Source:
# https://github.com/cassidylaidlaw/ReColorAdv/blob/master/recoloradv/mister_ed/loss_functions.py
#
# The license for the original version of this file can be
# found in the `recoloradv` directory (LICENSE_RECOLORADV).
# The modifications to this file are subject to the same license.
# ---------------------------------------------------------------
import torch.nn as nn
import torch
from numbers import Number
from .utils import pytorch_utils as utils
from .utils import image_utils as img_utils
from . import spatial_transformers as st
from torch.autograd import Variable
from functools import partial
from . import adversarial_perturbations as ap
""" Loss function building blocks """
##############################################################################
# #
# LOSS FUNCTION WRAPPER #
# #
##############################################################################
class RegularizedLoss(object):
""" Wrapper for multiple PartialLoss objects where we combine with
regularization constants """
def __init__(self, losses, scalars, negate=False):
"""
ARGS:
losses : dict - dictionary of partialLoss objects, each is keyed
with a nice identifying name
scalars : dict - dictionary of scalars, each is keyed with the
same identifying name as is in self.losses
negate : bool - if True, we negate the whole thing at the end
"""
assert sorted(losses.keys()) == sorted(scalars.keys())
self.losses = losses
self.scalars = scalars
self.negate = negate
def forward(self, examples, labels, *args, **kwargs):
output = None
output_per_example = kwargs.get('output_per_example', False)
for k in self.losses:
loss = self.losses[k]
scalar = self.scalars[k]
loss_val = loss.forward(examples, labels, *args, **kwargs)
# assert scalar is either a...
assert (isinstance(scalar, float) or # number
scalar.numel() == 1 or # tf wrapping of a number
scalar.shape == loss_val.shape) # same as the loss_val
addendum = loss_val * scalar
if addendum.numel() > 1:
if not output_per_example:
addendum = torch.sum(addendum)
if output is None:
output = addendum
else:
output = output + addendum
if self.negate:
return output * -1
else:
return output
def setup_attack_batch(self, fix_im):
""" Setup before calling loss on a new minibatch. Ensures the correct
fix_im for reference regularizers and that all grads are zeroed
ARGS:
fix_im: Variable (NxCxHxW) - Ground images for this minibatch
SHOULD BE IN [0.0, 1.0] RANGE
"""
for loss in self.losses.values():
if isinstance(loss, ReferenceRegularizer):
loss.setup_attack_batch(fix_im)
else:
loss.zero_grad()
def cleanup_attack_batch(self):
""" Does some cleanup stuff after we finish on a minibatch:
- clears the fixed images for ReferenceRegularizers
- zeros grads
- clears example-based scalars (i.e. scalars that depend on which
example we're using)
"""
for loss in self.losses.values():
if isinstance(loss, ReferenceRegularizer):
loss.cleanup_attack_batch()
else:
loss.zero_grad()
for key, scalar in self.scalars.items():
if not isinstance(scalar, Number):
self.scalars[key] = None
def zero_grad(self):
for loss in self.losses.values():
loss.zero_grad() # probably zeros the same net more than once...
class PartialLoss(object):
""" Partially applied loss object. Has forward and zero_grad methods """
def __init__(self):
self.nets = []
def zero_grad(self):
for net in self.nets:
net.zero_grad()
##############################################################################
# #
# LOSS FUNCTIONS #
# #
##############################################################################
############################################################################
# NAIVE CORRECT INDICATOR LOSS #
############################################################################
class IncorrectIndicator(PartialLoss):
def __init__(self, classifier, normalizer=None):
super(IncorrectIndicator, self).__init__()
self.classifier = classifier
self.normalizer = normalizer
def forward(self, examples, labels, *args, **kwargs):
""" Returns either (the number | a boolean vector) of examples that
don't match the labels when run through the
classifier(normalizer(.)) composition.
ARGS:
examples: Variable (NxCxHxW) - should be same shape as
ctx.fix_im, is the examples we define loss for.
SHOULD BE IN [0.0, 1.0] RANGE
labels: Variable (longTensor of length N) - true classification
output for fix_im/examples
KWARGS:
return_type: String - either 'int' or 'vector'. If 'int', we return
the number of correctly classified examples,
if 'vector' we return a boolean length-N longtensor
with the indices of
RETURNS:
scalar loss variable or boolean vector, depending on kwargs
"""
return_type = kwargs.get('return_type', 'int')
assert return_type in ['int', 'vector']
class_out = self.classifier.forward(self.normalizer.forward(examples))
_, outputs = torch.max(class_out, 1)
incorrect_indicator = outputs != labels
if return_type == 'int':
return torch.sum(incorrect_indicator)
else:
return incorrect_indicator
##############################################################################
# Standard XEntropy Loss #
##############################################################################
class PartialXentropy(PartialLoss):
def __init__(self, classifier, normalizer=None):
super(PartialXentropy, self).__init__()
self.classifier = classifier
self.normalizer = normalizer
self.nets.append(self.classifier)
def forward(self, examples, labels, *args, **kwargs):
""" Returns XEntropy loss
ARGS:
examples: Variable (NxCxHxW) - should be same shape as
ctx.fix_im, is the examples we define loss for.
SHOULD BE IN [0.0, 1.0] RANGE
labels: Variable (longTensor of length N) - true classification
output for fix_im/examples
RETURNS:
scalar loss variable
"""
if self.normalizer is not None:
normed_examples = self.normalizer.forward(examples)
else:
normed_examples = examples
xentropy_init_kwargs = {}
if kwargs.get('output_per_example') == True:
xentropy_init_kwargs['reduction'] = 'none'
criterion = nn.CrossEntropyLoss(**xentropy_init_kwargs)
return criterion(self.classifier.forward(normed_examples), labels)
##############################################################################
# Carlini Wagner loss functions #
##############################################################################
class CWLossF6(PartialLoss):
def __init__(self, classifier, normalizer=None, kappa=0.0):
super(CWLossF6, self).__init__()
self.classifier = classifier
self.normalizer = normalizer
self.nets.append(self.classifier)
self.kappa = kappa
def forward(self, examples, labels, *args, **kwargs):
classifier_in = self.normalizer.forward(examples)
classifier_out = self.classifier.forward(classifier_in)
# get target logits
target_logits = torch.gather(classifier_out, 1, labels.view(-1, 1))
# get largest non-target logits
max_2_logits, argmax_2_logits = torch.topk(classifier_out, 2, dim=1)
top_max, second_max = max_2_logits.chunk(2, dim=1)
top_argmax, _ = argmax_2_logits.chunk(2, dim=1)
targets_eq_max = top_argmax.squeeze().eq(labels).float().view(-1, 1)
targets_ne_max = top_argmax.squeeze().ne(labels).float().view(-1, 1)
max_other = targets_eq_max * second_max + targets_ne_max * top_max
if kwargs.get('targeted', False):
# in targeted case, want to make target most likely
f6 = torch.clamp(max_other - target_logits, min=-1 * self.kappa)
else:
# in NONtargeted case, want to make NONtarget most likely
f6 = torch.clamp(target_logits - max_other, min=-1 * self.kappa)
return f6.squeeze()
##############################################################################
# #
# REFERENCE REGULARIZERS #
# #
##############################################################################
""" Regularization terms that refer back to a set of 'fixed images', or the
original images.
example: L2 regularization which computes L2dist between a perturbed image
and the FIXED ORIGINAL IMAGE
NOTE: it's important that these return Variables that are scalars
(output.numel() == 1), otherwise there's a memory leak w/ CUDA.
See my discussion on this here:
https://discuss.pytorch.org/t/cuda-memory-not-being-freed/15965
"""
class ReferenceRegularizer(PartialLoss):
def __init__(self, fix_im):
super(ReferenceRegularizer, self).__init__()
self.fix_im = fix_im
def setup_attack_batch(self, fix_im):
""" Setup function to ensure fixed images are set
has been made; also zeros grads
ARGS:
fix_im: Variable (NxCxHxW) - Ground images for this minibatch
SHOULD BE IN [0.0, 1.0] RANGE
"""
self.fix_im = fix_im
self.zero_grad()
def cleanup_attack_batch(self):
""" Cleanup function to clear the fixed images after an attack batch
has been made; also zeros grads
"""
old_fix_im = self.fix_im
self.fix_im = None
del old_fix_im
self.zero_grad()
#############################################################################
# SOFT L_INF REGULARIZATION #
#############################################################################
class SoftLInfRegularization(ReferenceRegularizer):
'''
see page 10 of this paper (https://arxiv.org/pdf/1608.04644.pdf)
for discussion on why we want SOFT l inf
'''
def __init__(self, fix_im, **kwargs):
super(SoftLInfRegularization, self).__init__(fix_im)
def forward(self, examples, *args, **kwargs):
# ARGS should have one element, which serves as the tau value
tau = 8.0 / 255.0 # starts at 1 each time?
scale_factor = 0.9
l_inf_dist = float(torch.max(torch.abs(examples - self.fix_im)))
'''
while scale_factor * tau > l_inf_dist:
tau *= scale_factor
assert tau > l_inf_dist
'''
delta_minus_taus = torch.clamp(torch.abs(examples - self.fix_im) - tau,
min=0.0)
batchwise = utils.batchwise_norm(delta_minus_taus, 'inf', dim=0)
return batchwise.squeeze()
#############################################################################
# L2 REGULARIZATION #
#############################################################################
class L2Regularization(ReferenceRegularizer):
def __init__(self, fix_im, **kwargs):
super(L2Regularization, self).__init__(fix_im)
def forward(self, examples, *args, **kwargs):
l2_dist = img_utils.nchw_l2(examples, self.fix_im,
squared=True).view(-1, 1)
return l2_dist.squeeze()
#############################################################################
# LPIPS PERCEPTUAL REGULARIZATION #
#############################################################################
class LpipsRegularization(ReferenceRegularizer):
def __init__(self, fix_im, **kwargs):
super(LpipsRegularization, self).__init__(fix_im)
manual_gpu = kwargs.get('manual_gpu', None)
if manual_gpu is not None:
self.use_gpu = manual_gpu
else:
self.use_gpu = utils.use_gpu()
self.dist_model = dm.DistModel(net='alex', manual_gpu=self.use_gpu)
def forward(self, examples, *args, **kwargs):
xform = lambda im: im * 2.0 - 1.0
perceptual_loss = self.dist_model.forward_var(examples,
self.fix_im)
return perceptual_loss.squeeze()
#############################################################################
# SSIM PERCEPTUAL REGULARIZATION #
#############################################################################
class SSIMRegularization(ReferenceRegularizer):
def __init__(self, fix_im, **kwargs):
super(SSIMRegularization, self).__init__(fix_im)
if 'window_size' in kwargs:
self.ssim_instance = ssim.SSIM(window_size=kwargs['window_size'])
else:
self.ssim_instance = ssim.SSIM()
manual_gpu = kwargs.get('manual_gpu', None)
if manual_gpu is not None:
self.use_gpu = manual_gpu
else:
self.use_gpu = utils.use_gpu()
def forward(self, examples, *args, **kwargs):
output = []
for ex, fix_ex in zip(examples, self.fix_im):
output.append(1.0 - self.ssim_instance(ex.unsqueeze(0),
fix_ex.unsqueeze(0)))
return torch.stack(output)
##############################################################################
# #
# SPATIAL LOSS FUNCTIONS #
# #
##############################################################################
class FullSpatialLpLoss(PartialLoss):
""" Spatial loss using lp norms on the spatial transformation parameters
This is defined as the Lp difference between the identity map and the
provided spatial transformation parameters
"""
def __init__(self, **kwargs):
super(FullSpatialLpLoss, self).__init__()
lp = kwargs.get('lp', 2)
assert lp in [1, 2, 'inf']
self.lp = lp
def forward(self, examples, *args, **kwargs):
""" Computes lp loss between identity map and spatial transformation.
There better be a kwarg with key 'spatial' which is as FullSpatial
object describing how the examples were generated from the originals
"""
st_obj = kwargs['spatial']
assert isinstance(st_obj, st.FullSpatial)
# First create the identity map and make same type as examples
identity_map = Variable(st_obj.identity_params(examples.shape))
if examples.is_cuda:
identity_map.cuda()
# Then take diffs and take lp norms
diffs = st_obj.grid_params - identity_map
lp_norm = utils.batchwise_norm(diffs, self.lp, dim=0)
return lp_norm # return Nx1 variable, will sum in parent class
class PerturbationNormLoss(PartialLoss):
def __init__(self, **kwargs):
super(PerturbationNormLoss, self).__init__()
lp = kwargs.get('lp', 2)
assert lp in [1, 2, 'inf']
self.lp = lp
def forward(self, examples, *args, **kwargs):
""" Computes perturbation norm and multiplies by scale
There better be a kwarg with key 'perturbation' which is a perturbation
object with a 'perturbation_norm' method that takes 'lp_style' as a
kwarg
"""
perturbation = kwargs['perturbation']
assert isinstance(perturbation, ap.AdversarialPerturbation)
return perturbation.perturbation_norm(lp_style=self.lp)
##############################################################################
# #
# Combined Transformer Loss #
# #
##############################################################################
class CombinedTransformerLoss(ReferenceRegularizer):
""" General class for distance functions and loss functions of the form
min_T ||X - T(Y)|| + c * || T ||
where X is the original image, and Y is the 'adversarial' input image.
"""
def __init__(self, fix_im, transform_class=None,
regularization_constant=1.0,
transformation_loss=partial(utils.summed_lp_norm, lp=2),
transform_norm_kwargs=None):
""" Takes in a reference fix im and a class of transformations we need
to search over to compute forward.
"""
super(CombinedTransformerLoss, self).__init__(fix_im)
self.transform_class = transform_class
self.regularization_constant = regularization_constant
self.transformation_loss = transformation_loss
self.transform_norm_kwargs = transform_norm_kwargs or {}
self.transformer = None
def cleanup_attack_batch(self):
super(CombinedTransformerLoss, self).cleanup_attack_batch()
self.transformer = None
def _inner_loss(self, examples):
""" Computes the combined loss for a particular transformation """
trans_examples = self.transformer.forward(examples)
trans_loss = self.transformation_loss(self.fix_im - trans_examples)
trans_norm = self.transformer.norm(**self.transform_norm_kwargs)
return trans_loss + trans_norm * self.regularization_constant
def forward(self, examples, *args, **kwargs):
""" Computes the distance between examples and args
ARGS:
examples : NxCxHxW Variable - 'adversarially' perturbed image from
the self.fix_im
KWARGS:
optimization stuff here
"""
######################################################################
# Setup transformer + optimizer #
######################################################################
self.transformer = self.transform_class(shape=examples.shape)
optim_kwargs = kwargs.get('xform_loss_optim_kwargs', {})
optim_type = kwargs.get('xform_loss_optim_type', torch.optim.Adam)
num_iter = kwargs.get('xform_loss_num_iter', 20)
optimizer = optim_type(self.transformer.parameters(), **optim_kwargs)
#####################################################################
# Iterate and optimize the transformer #
#####################################################################
for iter_no in range(num_iter):
optimizer.zero_grad()
loss = self._inner_loss(examples)
loss.backward()
optimizer.step()
return self._inner_loss(examples)
class RelaxedTransformerLoss(ReferenceRegularizer):
""" Relaxed version of transformer loss: assumes that the adversarial
examples are of the form Y=S(X) + delta for some S in the
transformation class and some small delta perturbation outside the
perturbation.
In this case, we just compute ||delta|| + c||S||
This saves us from having to do the inner minmization step
"""
def __init__(self, fix_im,
regularization_constant=1.0,
transformation_loss=partial(utils.summed_lp_norm, lp=2),
transform_norm_kwargs=None):
""" Takes in a reference fix im and a class of transformations we need
to search over to compute forward.
"""
super(RelaxedTransformerLoss, self).__init__(fix_im)
self.regularization_constant = regularization_constant
self.transformation_loss = transformation_loss
self.transform_norm_kwargs = transform_norm_kwargs or {}
def forward(self, examples, *args, **kwargs):
""" Computes the distance between examples and args
ARGS:
examples : NxCxHxW Variable - 'adversarially' perturbed image from
the self.fix_im
KWARGS:
optimization stuff here
"""
# Collect transformer norm
transformer = kwargs['transformer']
assert isinstance(transformer, st.ParameterizedTransformation)
transformer_norm = self.regularization_constant * \
transformer.norm(**self.transform_norm_kwargs)
# Collect transformation loss
delta = self.transformer.forward(self.fix_im) - examples
transformation_loss = self.transformation_loss(delta)
return transformation_loss + transformer_norm
| 22,556 | 39.065719 | 97 | py |
DiffPure | DiffPure-master/stadv_eot/recoloradv/mister_ed/adversarial_perturbations.py | # ---------------------------------------------------------------
# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# This file has been modified from recoloradv.
#
# Source:
# https://github.com/cassidylaidlaw/ReColorAdv/blob/master/recoloradv/mister_ed/adversarial_perturbations.py
#
# The license for the original version of this file can be
# found in the `recoloradv` directory (LICENSE_RECOLORADV).
# The modifications to this file are subject to the same license.
# ---------------------------------------------------------------
""" File that holds adversarial perturbations as torch.nn.Modules.
An adversarial perturbation is an example-specific
"""
import torch
import torch.nn as nn
from . import spatial_transformers as st
from .utils import image_utils as img_utils
from .utils import pytorch_utils as utils
from torch.autograd import Variable
import functools
# assert initialized decorator
def initialized(func):
@functools.wraps(func)
def wrapper(self, *args, **kwargs):
assert self.initialized, ("Parameters not initialized yet. "
"Call .forward(...) first")
return func(self, *args, **kwargs)
return wrapper
##############################################################################
# #
# SKELETON CLASS #
# #
##############################################################################
class AdversarialPerturbation(nn.Module):
""" Skeleton class to hold adversarial perturbations FOR A SINGLE MINIBATCH.
For general input-agnostic adversarial perturbations, see the
ThreatModel class
All subclasses need the following:
- perturbation_norm() : no args -> scalar Variable
- self.parameters() needs to iterate over params we want to optimize
- constrain_params() : no args -> no return,
modifies the parameters such that this is still a valid image
- forward : no args -> Variable - applies the adversarial perturbation
the originals and outputs a Variable of how we got there
- adversarial_tensors() : applies the adversarial transform to the
originals and outputs TENSORS that are the
adversarial images
"""
def __init__(self, threat_model, perturbation_params):
super(AdversarialPerturbation, self).__init__()
self.threat_model = threat_model
self.initialized = False
self.perturbation_params = perturbation_params
if isinstance(perturbation_params, tuple):
self.use_gpu = perturbation_params[1].use_gpu or utils.use_gpu()
else:
self.use_gpu = perturbation_params.use_gpu or utils.use_gpu()
# Stores parameters of the adversarial perturbation and hyperparams
# to compute total perturbation norm here
def __call__(self, x):
return self.forward(x)
def __repr__(self):
if isinstance(self.perturbation_params, tuple):
output_str = "[Perturbation] %s: %s" % (self.__class__.__name__,
self.perturbation_params[1])
output_str += '\n['
for el in self.perturbation_params[0]:
output_str += '\n\t%s,' % el
output_str += '\n]'
return output_str
else:
return "[Perturbation] %s: %s" % (self.__class__.__name__,
self.perturbation_params)
def _merge_setup(self, *args):
""" Internal method to be used when initializing a new perturbation
from merging only. Should not be called outside this file!!
"""
pass
def setup(self, x):
""" This is the standard setup technique and should be used to
initialize a perturbation (i.e. sets up parameters and unlocks
all other methods)
ARGS:
x : Variable or Tensor (NxCxHxW) - the images this perturbation is
intended for
"""
self.num_examples = x.shape[0]
@initialized
def perturbation_norm(self, x=None):
""" This returns the 'norm' of this perturbation. Optionally, for
certain norms, having access to the images for which the
perturbation is intended can have an effect on the output.
ARGS:
x : Variable or Tensor (NxCxHxW) - optionally can be the images
that the perturbation was intended for
RETURNS:
Scalar Variable
"""
raise NotImplementedError("Need to call subclass method here")
@initialized
def constrain_params(self):
""" This modifies the parameters such that the perturbation falls within
the threat model it belongs to. E.g. for l-infinity threat models,
this clips the params to match the right l-infinity bound.
TODO: for non-lp norms, projecting to the nearest point in the level
set
"""
raise NotImplementedError("Need to call subclass method here")
@initialized
def make_valid_image(self, x):
""" This takes in the minibatch self's parameters were tuned for and
clips the parameters such that this is still a valid image.
ARGS:
x : Variable or Tensor (NxCxHxW) - the images this this perturbation
was intended for
RETURNS:
None
"""
pass # Only implement in classes that can create invalid images
@initialized
def forward(self, x):
""" This takes in the minibatch self's parameters were tuned for and
outputs a variable of the perturbation applied to the images
ARGS:
x : Variable (NxCxHxW) - the images this this perturbation
was intended for
RETURNS:
Variable (NxCxHxW) - the perturbation applied to the input images
"""
raise NotImplementedError("Need to call subclass method here")
@initialized
def add_to_params(self, grad_data):
""" This takes in a Tensor the same shape as self's parameters and
adds to them. Note that this usually won't preserve gradient
information
(also this might have different signatures in subclasses)
ARGS:
x : Tensor (params-shape) - Tensor to be added to the
parameters of self
RETURNS:
None, but modifies self's parameters
"""
raise NotImplementedError("Need to call subclass method here")
@initialized
def update_params(self, step_fxn):
""" This takes in a function step_fxn: Tensor -> Tensor that generates
the change to the parameters that we step along. This loops through
all parameters and updates signs accordingly.
For sequential perturbations, this also multiplies by a scalar if
provided
ARGS:
step_fxn : Tensor -> Tensor - function that maps tensors to tensors.
e.g. for FGSM, we want a function that multiplies signs
by step_size
RETURNS:
None, but updates the parameters
"""
raise NotImplementedError("Need to call subclass method here")
@initialized
def adversarial_tensors(self, x=None):
""" Little helper method to get the tensors of the adversarial images
directly
"""
assert x is not None or self.originals is not None
if x is None:
x = self.originals
return self.forward(x).data
@initialized
def attach_attr(self, attr_name, attr):
""" Special method to set an attribute if it doesn't exist in this
object yet. throws error if this attr already exists
ARGS:
attr_name : string - name of attribute we're attaching
attr: object - attribute we're attaching
RETURNS:
None
"""
if hasattr(self, attr_name):
raise Exception("%s already has attribute %s" % (self, attr_name))
else:
setattr(self, attr_name, attr)
@initialized
def attach_originals(self, originals):
""" Little helper method to tack on the original images to self to
pass around the (images, perturbation) in a single object
"""
self.attach_attr('originals', originals)
@initialized
def random_init(self):
""" Modifies the parameters such that they're randomly initialized
uniformly across the threat model (this is harder for nonLp threat
models...). Takes no args and returns nothing, but modifies the
parameters
"""
raise NotImplementedError("Need to call subclass method here")
@initialized
def merge_perturbation(self, other, self_mask):
""" Special technique to merge this perturbation with another
perturbation of the same threat model.
This will return a new perturbation object that, for each parameter
will return the parameters of self for self_mask, and the
perturbation of other for NOT(self_mask)
ARGS:
other: AdversarialPerturbation Object - instance of other
adversarial perturbation that is instantiated with the
same threat model as self
self_indices: ByteTensor [N] : bytetensor indicating which
parameters to include from self and which to include
from other
"""
# this parent class just does the shared asserts such that this is a
# valid thing
assert self.__class__ == other.__class__
assert self.threat_model == other.threat_model
assert self.num_examples == other.num_examples
assert self.perturbation_params == other.perturbation_params
assert other.initialized
@initialized
def collect_successful(self, classifier_net, normalizer):
""" Returns a list of [adversarials, originals] of the SUCCESSFUL
attacks only, according to the given classifier_net, normalizer
SUCCESSFUL here means that the adversarial is different
ARGS:
TODO: fill in when I'm not in crunchtime
"""
assert self.originals is not None
adversarials = Variable(self.adversarial_tensors())
originals = Variable(self.originals)
adv_out = torch.max(classifier_net(normalizer(adversarials)), 1)[1]
out = torch.max(classifier_net(normalizer(originals)), 1)[1]
adv_idx_bytes = adv_out != out
idxs = []
for idx, el in enumerate(adv_idx_bytes):
if float(el) > 0:
idxs.append(idx)
idxs = torch.LongTensor(idxs)
if self.originals.is_cuda:
idxs = idxs.cuda()
return [torch.index_select(self.adversarial_tensors(), 0, idxs),
torch.index_select(self.originals, 0, idxs)]
@initialized
def collect_adversarially_successful(self, classifier_net, normalizer,
labels):
""" Returns an object containing the SUCCESSFUL attacked examples,
their corresponding originals, and the number of misclassified
examples
ARGS:
classifier_net : nn.Module subclass - neural net that is the
relevant classifier
normalizer : DifferentiableNormalize object - object to convert
input data to mean-zero, unit-var examples
labels : Variable (longTensor N) - correct labels for classification
of self.originals
RETURNS:
dict with structure:
{'adversarials': Variable(N'xCxHxW) - adversarial perturbation
applied
'originals': Variable(N'xCxHxW) - unperturbed examples that
were correctly classified AND
successfully attacked
'num_correctly_classified': int - number of correctly classified
unperturbed examples
}
"""
assert self.originals is not None
adversarials = Variable(self.adversarial_tensors())
originals = Variable(self.originals)
adv_out = torch.max(classifier_net(normalizer(adversarials)), 1)[1]
out = torch.max(classifier_net(normalizer(originals)), 1)[1]
# First take a subset of correctly classified originals
correct_idxs = (out == labels) # correctly classified idxs
adv_idx_bytes = (adv_out != out) # attacked examples
num_correctly_classified = int(sum(correct_idxs))
adv_idxs = adv_idx_bytes * correct_idxs
idxs = []
for idx, el in enumerate(adv_idxs):
if float(el) > 0:
idxs.append(idx)
idxs = torch.LongTensor(idxs)
if self.originals.is_cuda:
idxs = idxs.cuda()
return {'adversarial': torch.index_select(self.adversarial_tensors(),
0, idxs),
'originals': torch.index_select(self.originals, 0, idxs),
'num_correctly_classified': num_correctly_classified}
@initialized
def display(self, scale=5, successful_only=False, classifier_net=None,
normalizer=None):
""" Displays this adversarial perturbation in a 3-row format:
top row is adversarial images, second row is original images,
bottom row is difference magnified by scale (default 5)
ARGS:
scale: int - how much to magnify differences by
successful_only: bool - if True we only display successful (in that
advs output different classifier outputs)
If this is not None, classifie_net and normalizer
cannot be None
RETURNS:
None, but displays images
"""
if successful_only:
assert classifier_net is not None
assert normalizer is not None
advs, origs = self.collect_successful(classifier_net, normalizer)
else:
advs = self.adversarial_tensors()
origs = self.originals
diffs = torch.clamp((advs - origs) * scale + 0.5, 0, 1)
img_utils.show_images([advs, origs, diffs])
class PerturbationParameters(dict):
""" Object that stores parameters like a dictionary.
This allows perturbation classes to be only partially instantiated and
then fed various 'originals' later.
Implementation taken from : https://stackoverflow.com/a/14620633/3837607
(and then modified with the getattribute trick to return none instead of
error for missing attributes)
"""
def __init__(self, *args, **kwargs):
super(PerturbationParameters, self).__init__(*args, **kwargs)
if kwargs.get('manual_gpu') is not None:
self.use_gpu = kwargs['manual_gpu']
else:
self.use_gpu = utils.use_gpu()
self.__dict__ = self
def __getattribute__(self, name):
try:
return object.__getattribute__(self, name)
except AttributeError:
return None
class ThreatModel(object):
def __init__(self, perturbation_class, param_kwargs, *other_args):
""" Factory class to generate per_minibatch instances of Adversarial
perturbations.
ARGS:
perturbation_class : class - subclass of Adversarial Perturbations
param_kwargs : dict - dict containing named kwargs to instantiate
the class in perturbation class
"""
assert issubclass(perturbation_class, AdversarialPerturbation)
self.perturbation_class = perturbation_class
if isinstance(param_kwargs, dict):
param_kwargs = PerturbationParameters(**param_kwargs)
self.param_kwargs = param_kwargs
self.other_args = other_args
def __repr__(self):
return "[Threat] %s: %s" % (str(self.perturbation_class.__name__),
self.param_kwargs)
def __call__(self, *args):
if args == ():
return self.perturbation_obj()
else:
perturbation_obj = self.perturbation_obj()
perturbation_obj.setup(*args)
return perturbation_obj
def perturbation_obj(self):
return self.perturbation_class(self, self.param_kwargs, *self.other_args)
##############################################################################
# #
# ADDITION PARAMETERS #
# #
##############################################################################
class DeltaAddition(AdversarialPerturbation):
def __init__(self, threat_model, perturbation_params, *other_args):
""" Maintains a delta that gets addded to the originals to generate
adversarial images. This is the type of adversarial perturbation
that the literature extensivey studies
ARGS:
threat_model : ThreatModel object that is used to initialize self
perturbation_params: PerturbationParameters object.
{ lp_style : None, int or 'inf' - if not None is the type of
Lp_bound that we apply to this adversarial example
lp_bound : None or float - cannot be None if lp_style is
not None, but if not None should be the lp bound
we allow for adversarial perturbations
custom_norm : None or fxn:(NxCxHxW) -> Scalar Variable. This is
not implemented for now
}
"""
super(DeltaAddition, self).__init__(threat_model, perturbation_params)
self.lp_style = perturbation_params.lp_style
self.lp_bound = perturbation_params.lp_bound
if perturbation_params.custom_norm is not None:
raise NotImplementedError("Only LP norms allowed for now")
self.scalar_step = perturbation_params.scalar_step or 1.0
def _merge_setup(self, num_examples, delta_data):
""" DANGEROUS TO BE CALLED OUTSIDE OF THIS FILE!!!"""
self.num_examples = num_examples
self.delta = nn.Parameter(delta_data)
self.initialized = True
def setup(self, x):
super(DeltaAddition, self).setup(x)
self.delta = nn.Parameter(torch.zeros_like(x))
self.initialized = True
@initialized
def perturbation_norm(self, x=None, lp_style=None):
lp_style = lp_style or self.lp_style
assert isinstance(lp_style, int) or lp_style == 'inf'
return utils.batchwise_norm(self.delta, lp=lp_style)
@initialized
def constrain_params(self):
new_delta = utils.batchwise_lp_project(self.delta.data, self.lp_style,
self.lp_bound)
delta_diff = new_delta - self.delta.data
self.delta.data.add_(delta_diff)
@initialized
def make_valid_image(self, x):
new_delta = self.delta.data
change_in_delta = utils.clamp_0_1_delta(new_delta, x)
self.delta.data.add_(change_in_delta)
@initialized
def update_params(self, step_fxn):
assert self.delta.grad.data is not None
self.add_to_params(step_fxn(self.delta.grad.data) * self.scalar_step)
@initialized
def add_to_params(self, grad_data):
""" sets params to be self.params + grad_data """
self.delta.data.add_(grad_data)
@initialized
def random_init(self):
self.delta = nn.Parameter(utils.random_from_lp_ball(self.delta.data,
self.lp_style,
self.lp_bound))
@initialized
def merge_perturbation(self, other, self_mask):
super(DeltaAddition, self).merge_perturbation(other, self_mask)
# initialize a new perturbation
new_perturbation = DeltaAddition(self.threat_model,
self.perturbation_params)
# make the new parameters
new_delta = utils.fold_mask(self.delta.data, other.delta.data,
self_mask)
# do the merge setup and return the object
new_perturbation._merge_setup(self.num_examples,
new_delta)
return new_perturbation
def forward(self, x):
if not self.initialized:
self.setup(x)
self.make_valid_image(x) # not sure which one to do first...
self.constrain_params()
return x + self.delta
##############################################################################
# #
# SPATIAL PARAMETERS #
# #
##############################################################################
class ParameterizedXformAdv(AdversarialPerturbation):
def __init__(self, threat_model, perturbation_params, *other_args):
super(ParameterizedXformAdv, self).__init__(threat_model,
perturbation_params)
assert issubclass(perturbation_params.xform_class,
st.ParameterizedTransformation)
self.lp_style = perturbation_params.lp_style
self.lp_bound = perturbation_params.lp_bound
self.use_stadv = perturbation_params.use_stadv
self.scalar_step = perturbation_params.scalar_step or 1.0
def _merge_setup(self, num_examples, new_xform):
""" DANGEROUS TO BE CALLED OUTSIDE OF THIS FILE!!!"""
self.num_examples = num_examples
self.xform = new_xform
self.initialized = True
def setup(self, originals):
super(ParameterizedXformAdv, self).setup(originals)
self.xform = self.perturbation_params.xform_class(shape=originals.shape,
manual_gpu=self.use_gpu)
self.initialized = True
@initialized
def perturbation_norm(self, x=None, lp_style=None):
lp_style = lp_style or self.lp_style
if self.use_stadv is not None:
assert isinstance(self.xform, st.FullSpatial)
return self.xform.stAdv_norm()
else:
return self.xform.norm(lp=lp_style)
@initialized
def constrain_params(self, x=None):
# Do lp projections
if isinstance(self.lp_style, int) or self.lp_style == 'inf':
self.xform.project_params(self.lp_style, self.lp_bound)
@initialized
def update_params(self, step_fxn):
param_list = list(self.xform.parameters())
assert len(param_list) == 1
params = param_list[0]
assert params.grad.data is not None
self.add_to_params(step_fxn(params.grad.data) * self.scalar_step)
@initialized
def add_to_params(self, grad_data):
""" Assumes only one parameters object in the Spatial Transform """
param_list = list(self.xform.parameters())
assert len(param_list) == 1
params = param_list[0]
params.data.add_(grad_data)
@initialized
def random_init(self):
param_list = list(self.xform.parameters())
assert len(param_list) == 1
param = param_list[0]
random_perturb = utils.random_from_lp_ball(param.data,
self.lp_style,
self.lp_bound)
param.data.add_(self.xform.identity_params(self.xform.img_shape) +
random_perturb - self.xform.xform_params.data)
@initialized
def merge_perturbation(self, other, self_mask):
super(ParameterizedXformAdv, self).merge_perturbation(other, self_mask)
new_perturbation = ParameterizedXformAdv(self.threat_model,
self.perturbation_params)
new_xform = self.xform.merge_xform(other.xform, self_mask)
new_perturbation._merge_setup(self.num_examples, new_xform)
return new_perturbation
def forward(self, x):
if not self.initialized:
self.setup(x)
self.constrain_params()
return self.xform.forward(x)
##############################################################################
# #
# SPATIAL + ADDITION PARAMETERS #
# #
##############################################################################
class SequentialPerturbation(AdversarialPerturbation):
""" Takes a list of perturbations and composes them. A norm needs to
be specified here to describe the perturbations.
"""
def __init__(self, threat_model, perturbation_sequence,
global_parameters=PerturbationParameters(pad=10),
preinit_pipeline=None):
""" Initializes a sequence of adversarial perturbation layers
ARGS:
originals : NxCxHxW tensor - original images we create adversarial
perturbations for
perturbation_sequence : ThreatModel[] -
list of ThreatModel objects
global_parameters : PerturbationParameters - global parameters to
use. These contain things like how to norm this
sequence, how to constrain this sequence, etc
preinit_pipelines: list[]
if not None i
"""
super(SequentialPerturbation, self).__init__(threat_model,
(perturbation_sequence,
global_parameters))
if preinit_pipeline is not None:
layers = preinit_pipeline
else:
layers = []
for threat_model in perturbation_sequence:
assert isinstance(threat_model, ThreatModel)
layers.append(threat_model())
self.pipeline = []
for layer_no, layer in enumerate(layers):
self.pipeline.append(layer)
self.add_module('layer_%02d' % layer_no, layer)
# norm: pipeline -> Scalar Variable
self.norm = global_parameters.norm
self.norm_weights = global_parameters.norm_weights
# padding with black is useful to not throw information away during
# sequential steps
self.pad = nn.ConstantPad2d(global_parameters.pad or 0, 0)
self.unpad = nn.ConstantPad2d(-1 * (global_parameters.pad or 0), 0)
def _merge_setup(self, num_examples):
self.num_examples = num_examples
self.initialized = True
def setup(self, x):
super(SequentialPerturbation, self).setup(x)
x = self.pad(x)
for layer in self.pipeline:
layer.setup(x)
self.initialized = True
@initialized
def perturbation_norm(self, x=None, lp_style=None):
# Need to define a nice way to describe the norm here. This can be
# an empirical norm between input/output
# For now, let's just say it's the sum of the norms of each constituent
if self.norm is not None:
return self.norm(self.pipeline, x=x, lp_style=lp_style)
else:
norm_weights = self.norm_weights or\
[1.0 for _ in range(len(self.pipeline))]
out = None
for i, layer in enumerate(self.pipeline):
weight = norm_weights[i]
layer_norm = layer.perturbation_norm(x=x, lp_style=lp_style)
if out is None:
out = layer_norm * weight
else:
out = out + layer_norm * weight
return out
@initialized
def make_valid_image(self, x):
x = self.pad(x)
for layer in self.pipeline:
layer.make_valid_image(x)
x = layer(x)
@initialized
def constrain_params(self):
# Need to do some sort of crazy projection operator for general things
# For now, let's just constrain each thing in sequence
for layer in self.pipeline:
layer.constrain_params()
@initialized
def update_params(self, step_fxn):
for layer in self.pipeline:
layer.update_params(step_fxn)
@initialized
def merge_perturbation(self, other, self_mask):
super(SequentialPerturbation, self).merge_perturbation(other, self_mask)
new_pipeline = []
for self_layer, other_layer in zip(self.pipeline, other.pipeline):
new_pipeline.append(self_layer.merge_perturbation(other_layer,
self_mask))
layer_params, global_params = self.perturbation_params
new_perturbation = SequentialPerturbation(self.threat_model,
layer_params,
global_parameters=global_params,
preinit_pipeline=new_pipeline)
new_perturbation._merge_setup(self.num_examples)
return new_perturbation
def forward(self, x, layer_slice=None):
""" Layer slice here is either an int or a tuple
If int, we run forward only the first layer_slice layers
If tuple, we start at the
"""
# Blocks to handle only particular layer slices (debugging)
if layer_slice is None:
pipeline_iter = iter(self.pipeline)
elif isinstance(layer_slice, int):
pipeline_iter = iter(self.pipeline[:layer_slice])
elif isinstance(layer_slice, tuple):
pipeline_iter = iter(self.pipeline[layer_slice[0]: layer_slice[1]])
# End block to handle particular layer slices
# Handle padding
original_hw = x.shape[-2:]
if not self.initialized:
self.setup(x)
self.constrain_params()
self.make_valid_image(x)
x = self.pad(x)
for layer in pipeline_iter:
x = layer(x)
return self.unpad(x)
@initialized
def random_init(self):
for layer in self.pipeline:
layer.random_init()
@initialized
def attach_originals(self, originals):
self.originals = originals
for layer in self.pipeline:
layer.attach_originals(originals)
| 31,509 | 37.710074 | 108 | py |
DiffPure | DiffPure-master/stadv_eot/recoloradv/mister_ed/spatial_transformers.py | # ---------------------------------------------------------------
# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# This file has been modified from recoloradv.
#
# Source:
# https://github.com/cassidylaidlaw/ReColorAdv/blob/master/recoloradv/mister_ed/spatial_transformers.py
#
# The license for the original version of this file can be
# found in the `recoloradv` directory (LICENSE_RECOLORADV).
# The modifications to this file are subject to the same license.
# ---------------------------------------------------------------
""" File that contains various parameterizations for spatial transformation
styles. At its simplest, spatial transforms can be affine grids,
parameterized by 6 values. At their most complex, for a CxHxW type image
grids can be parameterized by CxHxWx2 parameters.
This file will define subclasses of nn.Module that will have parameters
corresponding to the transformation parameters and will take in an image
and output a transformed image.
Further we'll also want a method to initialize each set to be the identity
initially
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
from .utils import pytorch_utils as utils
from torch.autograd import Variable
##############################################################################
# #
# SKELETON CLASS #
# #
##############################################################################
class ParameterizedTransformation(nn.Module):
""" General class of transformations.
All subclasses need the following methods:
- norm: no args -> scalar variable
- identity_params: shape -> TENSOR : takes an input shape and outputs
the subclass-specific parameter for the identity
transformation
- forward : Variable -> Variable - is the transformation
"""
def __init__(self, **kwargs):
super(ParameterizedTransformation, self).__init__()
if kwargs.get('manual_gpu', None) is not None:
self.use_gpu = kwargs['manual_gpu']
else:
self.use_gpu = utils.use_gpu()
def norm(self, lp='inf'):
raise NotImplementedError("Need to call subclass's norm!")
@classmethod
def identity_params(self, shape):
raise NotImplementedError("Need to call subclass's identity_params!")
def merge_xform(self, other, self_mask):
""" Takes in an other instance of this same class with the same
shape of parameters (NxSHAPE) and a self_mask bytetensor of length
N and outputs the merge between self's parameters for the indices
of 1s in the self_mask and other's parameters for the indices of 0's
ARGS:
other: instance of same class as self with params of shape NxSHAPE -
the thing we merge with this one
self_mask : ByteTensor (length N) - which indices of parameters we
keep from self, and which we keep from other
RETURNS:
New instance of this class that's merged between the self and other
(same shaped params)
"""
# JUST DO ASSERTS IN THE SKELETON CLASS
assert self.__class__ == other.__class__
self_params = self.xform_params.data
other_params = other.xform_params.data
assert self_params.shape == other_params.shape
assert self_params.shape[0] == self_mask.shape[0]
assert other_params.shape[0] == self_mask.shape[0]
new_xform = self.__class__(shape=self.img_shape)
new_params = utils.fold_mask(self.xform_params.data,
other.xform_params.data, self_mask)
new_xform.xform_params = nn.Parameter(new_params)
new_xform.use_gpu = self.use_gpu
return new_xform
def forward(self, examples):
raise NotImplementedError("Need to call subclass's forward!")
###############################################################################
# #
# FULLY PARAMETERIZED SPATIAL TRANSFORMATION NETWORK #
# #
###############################################################################
class FullSpatial(ParameterizedTransformation):
def __init__(self, *args, **kwargs):
""" FullSpatial just has parameters that are the grid themselves.
Forward then will just call grid sample using these params directly
"""
super(FullSpatial, self).__init__(**kwargs)
img_shape = kwargs['shape']
self.img_shape = img_shape
self.xform_params = nn.Parameter(self.identity_params(img_shape))
def identity_params(self, shape):
""" Returns some grid parameters such that the minibatch of images isn't
changed when forward is called on it
ARGS:
shape: torch.Size - shape of the minibatch of images we'll be
transforming. First index should be num examples
RETURNS:
torch TENSOR (not variable!!!)
if shape arg has shape NxCxHxW, this has shape NxCxHxWx2
"""
# Work smarter not harder -- use idenity affine transforms here
num_examples = shape[0]
identity_affine_transform = torch.zeros(num_examples, 2, 3)
if self.use_gpu:
identity_affine_transform = identity_affine_transform.cuda()
identity_affine_transform[:,0,0] = 1
identity_affine_transform[:,1,1] = 1
return F.affine_grid(identity_affine_transform, shape).data
def stAdv_norm(self):
""" Computes the norm used in
"Spatially Transformed Adversarial Examples"
"""
# ONLY WORKS FOR SQUARE MATRICES
dtype = self.xform_params.data.type()
num_examples, height, width = tuple(self.xform_params.shape[0:3])
assert height == width
######################################################################
# Build permutation matrices #
######################################################################
def id_builder():
x = torch.zeros(height, width).type(dtype)
for i in range(height):
x[i,i] = 1
return x
col_permuts = []
row_permuts = []
# torch.matmul(foo, col_permut)
for col in ['left', 'right']:
col_val = {'left': -1, 'right': 1}[col]
idx = ((torch.arange(width) - col_val) % width)
idx = idx.type(dtype).type(torch.LongTensor)
if self.xform_params.is_cuda:
idx = idx.cuda()
col_permut = torch.zeros(height, width).index_copy_(1, idx.cpu(),
id_builder().cpu())
col_permut = col_permut.type(dtype)
if col == 'left':
col_permut[-1][0] = 0
col_permut[0][0] = 1
else:
col_permut[0][-1] = 0
col_permut[-1][-1] = 1
col_permut = Variable(col_permut)
col_permuts.append(col_permut)
row_permuts.append(col_permut.transpose(0, 1))
######################################################################
# Build delta_u, delta_v grids #
######################################################################
id_params = Variable(self.identity_params(self.img_shape))
delta_grids = self.xform_params - id_params
delta_grids = delta_grids.permute(0, 3, 1, 2)
######################################################################
# Compute the norm #
######################################################################
output = Variable(torch.zeros(num_examples).type(dtype))
for row_or_col, permutes in zip(['row', 'col'],
[row_permuts, col_permuts]):
for permute in permutes:
if row_or_col == 'row':
temp = delta_grids - torch.matmul(permute, delta_grids)
else:
temp = delta_grids - torch.matmul(delta_grids, permute)
temp = temp.pow(2)
temp = temp.sum(1)
temp = (temp + 1e-10).pow(0.5)
output.add_(temp.sum((1, 2)))
return output
def norm(self, lp='inf'):
""" Returns the 'norm' of this transformation in terms of an LP norm on
the parameters, summed across each transformation per minibatch
ARGS:
lp : int or 'inf' - which lp type norm we use
"""
if isinstance(lp, int) or lp == 'inf':
identity_params = Variable(self.identity_params(self.img_shape))
return utils.batchwise_norm(self.xform_params - identity_params, lp,
dim=0)
else:
assert lp == 'stAdv'
return self._stAdv_norm()
def clip_params(self):
""" Clips the parameters to be between -1 and 1 as required for
grid_sample
"""
clamp_params = torch.clamp(self.xform_params, -1, 1).data
change_in_params = clamp_params - self.xform_params.data
self.xform_params.data.add_(change_in_params)
def merge_xform(self, other, self_mask):
""" Takes in an other instance of this same class with the same
shape of parameters (NxSHAPE) and a self_mask bytetensor of length
N and outputs the merge between self's parameters for the indices
of 1s in the self_mask and other's parameters for the indices of 0's
"""
super(FullSpatial, self).merge_xform(other, self_mask)
new_xform = FullSpatial(shape=self.img_shape,
manual_gpu=self.use_gpu)
new_params = utils.fold_mask(self.xform_params.data,
other.xform_params.data, self_mask)
new_xform.xform_params = nn.Parameter(new_params)
return new_xform
def project_params(self, lp, lp_bound):
""" Projects the params to be within lp_bound (according to an lp)
of the identity map. First thing we do is clip the params to be
valid, too
ARGS:
lp : int or 'inf' - which LP norm we use. Must be an int or the
string 'inf'
lp_bound : float - how far we're allowed to go in LP land
RETURNS:
None, but modifies self.xform_params
"""
assert isinstance(lp, int) or lp == 'inf'
# clip first
self.clip_params()
# then project back
if lp == 'inf':
identity_params = self.identity_params(self.img_shape)
clamp_params = utils.clamp_ref(self.xform_params.data,
identity_params, lp_bound)
change_in_params = clamp_params - self.xform_params.data
self.xform_params.data.add_(change_in_params)
else:
raise NotImplementedError("Only L-infinity bounds working for now ")
def forward(self, x):
# usual forward technique
return F.grid_sample(x, self.xform_params)
###############################################################################
# #
# AFFINE TRANSFORMATION NETWORK #
# #
###############################################################################
class AffineTransform(ParameterizedTransformation):
""" Affine transformation -- just has 6 parameters per example: 4 for 2d
rotation, and 1 for translation in each direction
"""
def __init__(self, *args, **kwargs):
super(AffineTransform, self).__init__(**kwargs)
img_shape = kwargs['shape']
self.img_shape = img_shape
self.xform_params = nn.Parameter(self.identity_params(img_shape))
def norm(self, lp='inf'):
identity_params = Variable(self.identity_params(self.img_shape))
return utils.batchwise_norm(self.xform_params - identity_params, lp,
dim=0)
def identity_params(self, shape):
""" Returns parameters for identity affine transformation
ARGS:
shape: torch.Size - shape of the minibatch of images we'll be
transforming. First index should be num examples
RETURNS:
torch TENSOR (not variable!!!)
if shape arg has shape NxCxHxW, this has shape Nx2x3
"""
# Work smarter not harder -- use idenity affine transforms here
num_examples = shape[0]
identity_affine_transform = torch.zeros(num_examples, 2, 3)
if self.use_gpu:
identity_affine_transform = identity_affine_transform.cuda()
identity_affine_transform[:,0,0] = 1
identity_affine_transform[:,1,1] = 1
return identity_affine_transform
def project_params(self, lp, lp_bound):
""" Projects the params to be within lp_bound (according to an lp)
of the identity map. First thing we do is clip the params to be
valid, too
ARGS:
lp : int or 'inf' - which LP norm we use. Must be an int or the
string 'inf'
lp_bound : float - how far we're allowed to go in LP land
RETURNS:
None, but modifies self.xform_params
"""
assert isinstance(lp, int) or lp == 'inf'
diff = self.xform_params.data - self.identity_params(self.img_shape)
new_diff = utils.batchwise_lp_project(diff, lp, lp_bound)
self.xform_params.data.add_(new_diff - diff)
def forward(self, x):
# usual forward technique with affine grid
grid = F.affine_grid(self.xform_params, x.shape)
return F.grid_sample(x, grid)
class RotationTransform(AffineTransform):
""" Rotations only -- only has one parameter, the angle by which we rotate
"""
def __init__(self, *args, **kwargs):
super(RotationTransform, self).__init__(**kwargs)
'''
img_shape = kwargs['shape']
self.img_shape = img_shape
self.xform_params = nn.Parameter(self.identity_params(img_shape))
'''
def identity_params(self, shape):
num_examples = shape[0]
params = torch.zeros(num_examples)
if self.use_gpu:
params = params.cuda()
return params
def make_grid(self, x):
assert isinstance(x, Variable)
cos_xform = self.xform_params.cos()
sin_xform = self.xform_params.sin()
zeros = torch.zeros_like(self.xform_params)
affine_xform = torch.stack([cos_xform, -sin_xform, zeros,
sin_xform, cos_xform, zeros])
affine_xform = affine_xform.transpose(0, 1).contiguous().view(-1, 2, 3)
return F.affine_grid(affine_xform, x.shape)
def forward(self, x):
return F.grid_sample(x, self.make_grid(x))
class TranslationTransform(AffineTransform):
""" Rotations only -- only has one parameter, the angle by which we rotate
"""
def __init__(self, *args, **kwargs):
super(TranslationTransform, self).__init__(**kwargs)
def identity_params(self, shape):
num_examples = shape[0]
params = torch.zeros(num_examples, 2) # x and y translation only
if self.use_gpu:
params = params.cuda()
return params
def make_grid(self, x):
assert isinstance(x, Variable)
ones = Variable(torch.ones(self.xform_params.shape[0]))
zeros = Variable(torch.zeros(self.xform_params.shape[0]))
if self.xform_params.cuda:
ones = ones.cuda()
zeros = zeros.cuda()
affine_xform = torch.stack([ones, zeros, self.xform_params[:,0],
zeros, ones, self.xform_params[:,1]])
affine_xform = affine_xform.transpose(0, 1).contiguous().view(-1, 2, 3)
return F.affine_grid(affine_xform, x.shape)
def forward(self, x):
return F.grid_sample(x, self.make_grid(x))
##############################################################################
# #
# BARREL + PINCUSHION TRANSFORMATIONS #
# #
##############################################################################
class PointScaleTransform(ParameterizedTransformation):
""" Point Scale transformations are pincushion/barrel distortions.
We pick a point to anchor the image and optimize a distortion size to
either dilate or contract
"""
def __init__(self, *args, **kwargs):
super(PointScaleTransform, self).__init__(**kwargs)
img_shape = kwargs['shape']
self.img_shape = img_shape
self.xform_params = nn.Parameter(self.identity_params(img_shape))
def norm(self, lp='inf'):
return utils.batchwise_norm(self.xform_params, lp, dim=0)
def project_params(self, lp, lp_bound):
""" Projects the params to be within lp_bound (according to an lp)
of the identity map. First thing we do is clip the params to be
valid, too
ARGS:
lp : int or 'inf' - which LP norm we use. Must be an int or the
string 'inf'
lp_bound : float - how far we're allowed to go in LP land
RETURNS:
None, but modifies self.xform_params
"""
assert isinstance(lp, int) or lp == 'inf'
diff = self.xform_params.data
new_diff = utils.batchwise_lp_project(diff, lp, lp_bound)
self.xform_params.data.add_(new_diff - diff)
def identity_params(self, shape):
num_examples = shape[0]
identity_param = torch.zeros(num_examples)
if self.use_gpu:
identity_param = identity_param.cuda()
return identity_param
def make_grid(self):
######################################################################
# Compute identity flow grid first #
######################################################################
num_examples = self.img_shape[0]
identity_affine_transform = torch.zeros(num_examples, 2, 3)
if self.use_gpu:
identity_affine_transform = identity_affine_transform.cuda()
identity_affine_transform[:,0,0] = 1
identity_affine_transform[:,1,1] = 1
basic_grid = F.affine_grid(identity_affine_transform, self.img_shape)
######################################################################
# Compute scaling based on parameters #
######################################################################
radii_squared = basic_grid.pow(2).sum(-1)
new_radii = (radii_squared + 1e-20).pow(0.5) *\
(1 + self.xform_params.view(-1, 1, 1) * radii_squared)
thetas = torch.atan2(basic_grid[:,:,:,1], (basic_grid[:,:,:, 0]))
cosines = torch.cos(thetas) * new_radii
sines = torch.sin(thetas) * new_radii
return torch.stack([cosines, sines], -1)
def forward(self, x):
return F.grid_sample(x, self.make_grid())
| 20,065 | 36.931947 | 103 | py |
DiffPure | DiffPure-master/stadv_eot/recoloradv/mister_ed/utils/pytorch_ssim.py | # ---------------------------------------------------------------
# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# This file has been modified from recoloradv.
#
# Source:
# https://github.com/cassidylaidlaw/ReColorAdv/blob/master/recoloradv/mister_ed/utils/pytorch_ssim.py
#
# The license for the original version of this file can be
# found in the `recoloradv` directory (LICENSE_RECOLORADV).
# The modifications to this file are subject to the same license.
# ---------------------------------------------------------------
""" Implementation directly lifted from Po-Hsun-Su for pytorch ssim
See github repo here: https://github.com/Po-Hsun-Su/pytorch-ssim
"""
import torch
import torch.nn.functional as F
from torch.autograd import Variable
from math import exp
def gaussian(window_size, sigma):
gauss = torch.Tensor([exp(-(x - window_size//2)**2/float(2*sigma**2)) for x in range(window_size)])
return gauss/gauss.sum()
def create_window(window_size, channel):
_1D_window = gaussian(window_size, 1.5).unsqueeze(1)
_2D_window = _1D_window.mm(_1D_window.t()).float().unsqueeze(0).unsqueeze(0)
window = Variable(_2D_window.expand(channel, 1, window_size, window_size).contiguous())
return window
def _ssim(img1, img2, window, window_size, channel, size_average = True):
mu1 = F.conv2d(img1, window, padding = window_size//2, groups = channel)
mu2 = F.conv2d(img2, window, padding = window_size//2, groups = channel)
mu1_sq = mu1.pow(2)
mu2_sq = mu2.pow(2)
mu1_mu2 = mu1*mu2
sigma1_sq = F.conv2d(img1*img1, window, padding = window_size//2, groups = channel) - mu1_sq
sigma2_sq = F.conv2d(img2*img2, window, padding = window_size//2, groups = channel) - mu2_sq
sigma12 = F.conv2d(img1*img2, window, padding = window_size//2, groups = channel) - mu1_mu2
C1 = 0.01**2
C2 = 0.03**2
ssim_map = ((2*mu1_mu2 + C1)*(2*sigma12 + C2))/((mu1_sq + mu2_sq + C1)*(sigma1_sq + sigma2_sq + C2))
if size_average:
return ssim_map.mean()
else:
return ssim_map.mean(1).mean(1).mean(1)
class SSIM(torch.nn.Module):
def __init__(self, window_size = 11, size_average = True):
super(SSIM, self).__init__()
self.window_size = window_size
self.size_average = size_average
self.channel = 1
self.window = create_window(window_size, self.channel)
def forward(self, img1, img2):
(_, channel, _, _) = img1.size()
if channel == self.channel and self.window.data.type() == img1.data.type():
window = self.window
else:
window = create_window(self.window_size, channel)
if img1.is_cuda:
window = window.cuda(img1.get_device())
window = window.type_as(img1)
self.window = window
self.channel = channel
return _ssim(img1, img2, window, self.window_size, channel, self.size_average)
def ssim(img1, img2, window_size = 11, size_average = True):
(_, channel, _, _) = img1.size()
window = create_window(window_size, channel)
if img1.is_cuda:
window = window.cuda(img1.get_device())
window = window.type_as(img1)
return _ssim(img1, img2, window, window_size, channel, size_average) | 3,267 | 35.719101 | 104 | py |
DiffPure | DiffPure-master/stadv_eot/recoloradv/mister_ed/utils/image_utils.py | # ---------------------------------------------------------------
# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# This file has been modified from recoloradv.
#
# Source:
# https://github.com/cassidylaidlaw/ReColorAdv/blob/master/recoloradv/mister_ed/utils/image_utils.py
#
# The license for the original version of this file can be
# found in the `recoloradv` directory (LICENSE_RECOLORADV).
# The modifications to this file are subject to the same license.
# ---------------------------------------------------------------
""" Specific utilities for image classification
(i.e. RGB images i.e. tensors of the form NxCxHxW )
"""
from __future__ import print_function
import torch
import numpy as np
import matplotlib.pyplot as plt
import random
def nhwc255_xform(img_np_array):
""" Takes in a numpy array and transposes it so that the channel is the last
axis. Also multiplies all values by 255.0
ARGS:
img_np_array : np.ndarray - array of shape (NxHxWxC) or (NxCxHxW)
[assumes that we're in NCHW by default,
but if not ambiguous will handle NHWC too ]
RETURNS:
array of form NHWC
"""
assert isinstance(img_np_array, np.ndarray)
shape = img_np_array.shape
assert len(shape) == 4
# determine which configuration we're in
ambiguous = (shape[1] == shape[3] == 3)
nhwc = (shape[1] == 3)
# transpose unless we're unambiguously in nhwc case
if nhwc and not ambiguous:
return img_np_array * 255.0
else:
return np.transpose(img_np_array, (0, 2, 3, 1)) * 255.0
def show_images(images, normalize=None, ipython=True,
margin_height=2, margin_color='red',
figsize=(18, 16)):
""" Shows pytorch tensors/variables as images """
# first format the first arg to be hz-stacked numpy arrays
if not isinstance(images, list):
images = [images]
images = [np.dstack(image.cpu().numpy()) for image in images]
image_shape = images[0].shape
assert all(image.shape == image_shape for image in images)
assert all(image.ndim == 3 for image in images) # CxHxW
# now build the list of final rows
rows = []
if margin_height > 0:
assert margin_color in ['red', 'black']
margin_shape = list(image_shape)
margin_shape[1] = margin_height
margin = np.zeros(margin_shape)
if margin_color == 'red':
margin[0] = 1
else:
margin = None
for image_row in images:
rows.append(margin)
rows.append(image_row)
rows = [_ for _ in rows[1:] if _ is not None]
plt.figure(figsize=figsize, dpi=80, facecolor='w', edgecolor='k')
cat_rows = np.concatenate(rows, 1).transpose(1, 2, 0)
imshow_kwargs = {}
if cat_rows.shape[-1] == 1: # 1 channel: greyscale
cat_rows = cat_rows.squeeze()
imshow_kwargs['cmap'] = 'gray'
plt.imshow(cat_rows, **imshow_kwargs)
plt.show()
def display_adversarial_2row(classifier_net, normalizer, original_images,
adversarial_images, num_to_show=4, which='incorrect',
ipython=False, margin_width=2):
""" Displays adversarial images side-by-side with their unperturbed
counterparts. Opens a window displaying two rows: top row is original
images, bottom row is perturbed
ARGS:
classifier_net : nn - with a .forward method that takes normalized
variables and outputs logits
normalizer : object w/ .forward method - should probably be an instance
of utils.DifferentiableNormalize or utils.IdentityNormalize
original_images: Variable or Tensor (NxCxHxW) - original images to
display. Images in [0., 1.] range
adversarial_images: Variable or Tensor (NxCxHxW) - perturbed images to
display. Should be same shape as original_images
num_to_show : int - number of images to show
which : string in ['incorrect', 'random', 'correct'] - which images to
show.
-- 'incorrect' means successfully attacked images,
-- 'random' means some random selection of images
-- 'correct' means unsuccessfully attacked images
ipython: bool - if True, we use in an ipython notebook so slightly
different way to show Images
margin_width - int : height in pixels of the red margin separating top
and bottom rows. Set to 0 for no margin
RETURNS:
None, but displays images
"""
assert which in ['incorrect', 'random', 'correct']
# If not 'random' selection, prune to only the valid things
to_sample_idxs = []
if which != 'random':
classifier_net.eval() # can never be too safe =)
# classify the originals with top1
original_norm_var = normalizer.forward(original_images)
original_out_logits = classifier_net.forward(original_norm_var)
_, original_out_classes = original_out_logits.max(1)
# classify the adversarials with top1
adv_norm_var = normalizer.forward(adversarial_images)
adv_out_logits = classifier_net.forward(adv_norm_var)
_, adv_out_classes = adv_out_logits.max(1)
# collect indices of matching
selector = lambda var: (which == 'correct') == bool(float(var))
for idx, var_el in enumerate(original_out_classes == adv_out_classes):
if selector(var_el):
to_sample_idxs.append(idx)
else:
to_sample_idxs = list(range(original_images.shape[0]))
# Now select some indices to show
if to_sample_idxs == []:
print("Couldn't show anything. Try changing the 'which' argument here")
return
to_show_idxs = random.sample(to_sample_idxs, min([num_to_show,
len(to_sample_idxs)]))
# Now start building up the images : first horizontally, then vertically
top_row = torch.cat([original_images[idx] for idx in to_show_idxs], dim=2)
bottom_row = torch.cat([adversarial_images[idx] for idx in to_show_idxs],
dim=2)
if margin_width > 0:
margin = torch.zeros(3, margin_width, top_row.shape[-1])
margin[0] = 1.0 # make it red
margin = margin.type(type(top_row))
stack = [top_row, margin, bottom_row]
else:
stack = [top_row, bottom_row]
plt.imshow(torch.cat(stack, dim=1).cpu().numpy().transpose(1, 2, 0))
plt.show()
def display_adversarial_notebook():
pass
def nchw_l2(x, y, squared=True):
""" Computes l2 norm between two NxCxHxW images
ARGS:
x, y: Tensor/Variable (NxCxHxW) - x, y must be same type & shape.
squared : bool - if True we return squared loss, otherwise we return
square root of l2
RETURNS:
||x - y ||_2 ^2 (no exponent if squared == False),
shape is (Nx1x1x1)
"""
temp = torch.pow(x - y, 2) # square diff
for i in range(1, temp.dim()): # reduce on all but first dimension
temp = torch.sum(temp, i, keepdim=True)
if not squared:
temp = torch.pow(temp, 0.5)
return temp.squeeze()
| 7,342 | 36.850515 | 100 | py |
DiffPure | DiffPure-master/stadv_eot/recoloradv/mister_ed/utils/checkpoints.py | # ---------------------------------------------------------------
# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# This file has been modified from recoloradv.
#
# Source:
# https://github.com/cassidylaidlaw/ReColorAdv/blob/master/recoloradv/mister_ed/utils/checkpoints.py
#
# The license for the original version of this file can be
# found in the `recoloradv` directory (LICENSE_RECOLORADV).
# The modifications to this file are subject to the same license.
# ---------------------------------------------------------------
""" Code for saving/loading pytorch models and batches of adversarial images
CHECKPOINT NAMING CONVENTIONS:
<unique_experiment_name>.<architecture_abbreviation>.<6 digits of epoch number>path.tar
e.g.
fgsm_def.resnet32.20180301.120000.path.tar
All checkpoints are stored in CHECKPOINT_DIR
Checkpoints are state dicts only!!!
"""
import torch
import os
import re
import glob
from .. import config
import numpy as np
import random
CHECKPOINT_DIR = config.MODEL_PATH
OUTPUT_IMAGE_DIR = config.OUTPUT_IMAGE_PATH
##############################################################################
# #
# CHECKPOINTING MODELS #
# #
##############################################################################
def clear_experiment(experiment_name, architecture):
""" Deletes all saved state dicts for an experiment/architecture pair """
for filename in params_to_filename(experiment_name, architecture):
full_path = os.path.join(*[CHECKPOINT_DIR, filename])
os.remove(full_path) if os.path.exists(full_path) else None
def list_saved_epochs(experiment_name, architecture):
""" Returns a list of int epochs we've checkpointed for this
experiment name and architecture
"""
extract_epoch = lambda f: int(f.split('.')[-3])
filename_list = params_to_filename(experiment_name, architecture)
return [extract_epoch(f) for f in filename_list]
def params_to_filename(experiment_name, architecture, epoch_val=None):
""" Outputs string name of file.
ARGS:
experiment_name : string - name of experiment we're saving
architecture : string - abbreviation for model architecture
epoch_val : int/(intLo, intHi)/None -
- if int we return this int exactly
- if (intLo, intHi) we return all existing filenames with
highest epoch in range (intLo, intHi), in sorted order
- if None, we return all existing filenames with params
in ascending epoch-sorted order
RETURNS:
filenames: string or (possibly empty) string[] of just the base name
of saved models
"""
if isinstance(epoch_val, int):
return '.'.join([experiment_name, architecture, '%06d' % epoch_val,
'path', 'tar'])
glob_prefix = os.path.join(*[CHECKPOINT_DIR,
'%s.%s.*' % (experiment_name, architecture)])
re_prefix = '%s\.%s\.' % (experiment_name, architecture)
re_suffix = r'\.path\.tar'
valid_name = lambda f: bool(re.match(re_prefix + r'\d{6}' + re_suffix, f))
select_epoch = lambda f: int(re.sub(re_prefix, '',
re.sub(re_suffix, '', f)))
valid_epoch = lambda e: (e >= (epoch_val or (0, 0))[0] and
e <= (epoch_val or (0, float('inf')))[1])
filename_epoch_pairs = []
for full_path in glob.glob(glob_prefix):
filename = os.path.basename(full_path)
if not valid_name(filename):
continue
epoch = select_epoch(filename)
if valid_epoch(epoch):
filename_epoch_pairs.append((filename, epoch))
return [_[0] for _ in sorted(filename_epoch_pairs, key=lambda el: el[1])]
def save_state_dict(experiment_name, architecture, epoch_val, model,
k_highest=10):
""" Saves the state dict of a model with the given parameters.
ARGS:
experiment_name : string - name of experiment we're saving
architecture : string - abbreviation for model architecture
epoch_val : int - which epoch we're saving
model : model - object we're saving the state dict of
k_higest : int - if not None, we make sure to not include more than
k state_dicts for (experiment_name, architecture) pair,
keeping the k-most recent if we overflow
RETURNS:
The model we saved
"""
# First resolve THIS filename
this_filename = params_to_filename(experiment_name, architecture, epoch_val)
# Next clear up memory if too many state dicts
current_filenames = params_to_filename(experiment_name, architecture)
delete_els = []
if k_highest is not None:
num_to_delete = len(current_filenames) - k_highest + 1
if num_to_delete > 0:
delete_els = sorted(current_filenames)[:num_to_delete]
for delete_el in delete_els:
full_path = os.path.join(*[CHECKPOINT_DIR, delete_el])
os.remove(full_path) if os.path.exists(full_path) else None
# Finally save the state dict
torch.save(model.state_dict(), os.path.join(*[CHECKPOINT_DIR,
this_filename]))
return model
def load_state_dict_from_filename(filename, model):
""" Skips the whole parameter argument thing and just loads the whole
state dict from a filename.
ARGS:
filename : string - filename without directories
model : nn.Module - has 'load_state_dict' method
RETURNS:
the model loaded with the weights contained in the file
"""
assert len(glob.glob(os.path.join(*[CHECKPOINT_DIR, filename]))) == 1
# LOAD FILENAME
# If state_dict in keys, use that as the loader
right_dict = lambda d: d.get('state_dict', d)
model.load_state_dict(right_dict(torch.load(
os.path.join(*[CHECKPOINT_DIR, filename]))))
return model
def load_state_dict(experiment_name, architecture, epoch, model):
""" Loads a checkpoint that was previously saved
experiment_name : string - name of experiment we're saving
architecture : string - abbreviation for model architecture
epoch_val : int - which epoch we're loading
"""
filename = params_to_filename(experiment_name, architecture, epoch)
return load_state_dict_from_filename(filename, model)
###############################################################################
# #
# CHECKPOINTING DATA #
# #
###############################################################################
"""
This is a hacky fix to save batches of adversarial images along with their
labels.
"""
class CustomDataSaver(object):
# TODO: make this more pytorch compliant
def __init__(self, image_subdirectory):
self.image_subdirectory = image_subdirectory
# make this folder if it doesn't exist yet
def save_minibatch(self, examples, labels):
""" Assigns a random name to this minibatch and saves the examples and
labels in two separate files:
<random_name>.examples.npy and <random_name>.labels.npy
ARGS:
examples: Variable or Tensor (NxCxHxW) - examples to be saved
labels : Variable or Tensor (N) - labels matching the examples
"""
# First make both examples and labels into numpy arrays
examples = examples.cpu().numpy()
labels = labels.cpu().numpy()
# Make a name for the files
random_string = str(random.random())[2:] # DO THIS BETTER WHEN I HAVE INTERNET
# Save both files
example_file = '%s.examples.npy' % random_string
example_path = os.path.join(OUTPUT_IMAGE_DIR, self.image_subdirectory,
example_file)
np.save(example_path, examples)
label_file = '%s.labels.npy' % random_string
label_path = os.path.join(OUTPUT_IMAGE_DIR, self.image_subdirectory,
label_file)
np.save(label_path, labels)
class CustomDataLoader(object):
# TODO: make this more pytorch compliant
def __init__(self, image_subdirectory, batch_size=128, to_tensor=True,
use_gpu=False):
super(CustomDataLoader, self).__init__()
self.image_subdirectory = image_subdirectory
self.batch_size = batch_size
assert to_tensor >= use_gpu
self.to_tensor = to_tensor
self.use_gpu = use_gpu
def _prepare_data(self, examples, labels):
""" Takes in numpy examples and labels and tensor-ifies and cuda's them
if necessary
"""
if self.to_tensor:
examples = torch.Tensor(examples)
labels = torch.Tensor(labels)
if self.use_gpu:
examples = examples.cuda()
labels = labels.cuda()
return (examples, labels)
def _base_loader(self, prefix, which):
assert which in ['examples', 'labels']
filename = '%s.%s.npy' % (prefix, which)
full_path = os.path.join(OUTPUT_IMAGE_DIR, self.image_subdirectory,
filename)
return np.load(full_path)
def _example_loader(self, prefix):
""" Loads the numpy array of examples given the random 'prefix' """
return self._base_loader(prefix, 'examples')
def _label_loader(self, prefix):
""" Loads the numpy array of labels given the random 'prefix' """
return self._base_loader(prefix, 'labels')
def __iter__(self):
# First collect all the filenames:
glob_prefix = os.path.join(OUTPUT_IMAGE_DIR, self.image_subdirectory,
'*')
files = glob.glob(glob_prefix)
valid_random_names = set(os.path.basename(_).split('.')[0]
for _ in files)
# Now loop through filenames and yield out minibatches of correct size
running_examples, running_labels = [], []
running_size = 0
for random_name in valid_random_names:
# Load data from files and append to 'running' lists
loaded_examples = self._example_loader(random_name)
loaded_labels = self._label_loader(random_name)
running_examples.append(loaded_examples)
running_labels.append(loaded_labels)
running_size += loaded_examples.shape[0]
if running_size < self.batch_size:
# Load enough data to populate one minibatch, which might
# take multiple files
continue
# Concatenate all images together
merged_examples = np.concatenate(running_examples, axis=0)
merged_labels = np.concatenate(running_labels, axis=0)
# Make minibatches out of concatenated things,
for batch_no in range(running_size // self.batch_size):
index_lo = batch_no * self.batch_size
index_hi = index_lo + self.batch_size
example_batch = merged_examples[index_lo:index_hi]
label_batch = merged_labels[index_lo:index_hi]
yield self._prepare_data(example_batch, label_batch)
# Handle any remainder for remaining files
remainder_idx = (running_size // self.batch_size) * self.batch_size
running_examples = [merged_examples[remainder_idx:]]
running_labels = [merged_labels[remainder_idx:]]
running_size = running_size - remainder_idx
# If we're out of files, yield this last sub-minibatch of data
if running_size > 0:
merged_examples = np.concatenate(running_examples, axis=0)
merged_labels = np.concatenate(running_labels, axis=0)
yield self._prepare_data(merged_examples, merged_labels)
| 12,317 | 38.480769 | 100 | py |
DiffPure | DiffPure-master/stadv_eot/recoloradv/mister_ed/utils/discretization.py | # ---------------------------------------------------------------
# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# This file has been modified from recoloradv.
#
# Source:
# https://github.com/cassidylaidlaw/ReColorAdv/blob/master/recoloradv/mister_ed/utils/discretization.py
#
# The license for the original version of this file can be
# found in the `recoloradv` directory (LICENSE_RECOLORADV).
# The modifications to this file are subject to the same license.
# ---------------------------------------------------------------
""" File that holds techniques for discretizing images --
In general, images of the form NxCxHxW will with values in the [0.,1.] range
need to be converted to the [0, 255 (int)] range to be displayed as images.
Sometimes the naive rounding scheme can mess up the classification, so this
file holds techniques to discretize these images into tensors with values
of the form i/255.0 for some integers i.
"""
import torch
from torch.autograd import Variable
from . import pytorch_utils as utils
##############################################################################
# #
# HELPER METHODS #
# #
##############################################################################
def discretize_image(img_tensor, zero_one=False):
""" Discretizes an image tensor into a tensor filled with ints ranging
between 0 and 255
ARGS:
img_tensor : floatTensor (NxCxHxW) - tensor to be discretized
pixel_max : int - discretization bucket size
zero_one : bool - if True divides output by 255 before returning it
"""
assert float(torch.min(img_tensor)) >= 0.
assert float(torch.max(img_tensor)) <= 1.0
original_shape = img_tensor.shape
if img_tensor.dim() != 4:
img_tensor = img_tensor.unsqueeze(0)
int_tensors = [] # actually floatTensor, but full of ints
img_shape = original_shape[1:]
for example in img_tensor:
pixel_channel_tuples = zip(*list(smp.toimage(example).getdata()))
int_tensors.append(img_tensor.new(pixel_channel_tuples).view(img_shape))
stacked_tensors = torch.stack(int_tensors)
if zero_one:
return stacked_tensors / 255.0
return stacked_tensors
##############################################################################
# #
# MAIN DISCRETIZATION TECHNIQUES #
# #
##############################################################################
def discretized_adversarial(img_tensor, classifier_net, normalizer,
flavor='greedy'):
""" Takes in an image_tensor and classifier/normalizer pair and outputs a
'discretized' image_tensor [each val is i/255.0 for some integer i]
with the same classification
ARGS:
img_tensor : tensor (NxCxHxW) - tensor of images with values between
0.0 and 1.0.
classifier_net : NN - neural net with .forward method to classify
normalized images
normalizer : differentiableNormalizer object - normalizes 0,1 images
into classifier_domain
flavor : string - either 'random' or 'greedy', determining which
'next_pixel_to_flip' function we use
RETURNS:
img_tensor of the same shape, but no with values of the form i/255.0
for integers i.
"""
img_tensor = utils.safe_tensor(img_tensor)
nptf_map = {'random': flip_random_pixel,
'greedy': flip_greedy_pixel}
next_pixel_to_flip = nptf_map[flavor](classifier_net, normalizer)
##########################################################################
# First figure out 'correct' labels and the 'discretized' labels #
##########################################################################
var_img = utils.safe_var(img_tensor)
norm_var = normalizer.forward(var_img)
norm_output = classifier_net.forward(norm_var)
correct_targets = norm_output.max(1)[1]
og_discretized = utils.safe_var(discretize_image(img_tensor, zero_one=True))
norm_discretized = normalizer.forward(og_discretized)
discretized_output = classifier_net.forward(norm_discretized)
discretized_targets = discretized_output.max(1)[1]
##########################################################################
# Collect idxs for examples affected by discretization #
##########################################################################
incorrect_idxs = set()
for i, el in enumerate(correct_targets.ne(discretized_targets)):
if float(el) != 0:
incorrect_idxs.add(i)
##########################################################################
# Fix all bad images #
##########################################################################
corrected_imgs = []
for idx in incorrect_idxs:
desired_target = correct_targets[idx]
example = og_discretized[idx].data.clone() # tensor
signs = torch.sign(var_img - og_discretized)
bad_discretization = True
pixels_changed_so_far = set() # populated with tuples of idxs
while bad_discretization:
pixel_idx, grad_sign = next_pixel_to_flip(example,
pixels_changed_so_far,
desired_target)
pixels_changed_so_far.add(pixel_idx)
if grad_sign == 0:
grad_sign = utils.tuple_getter(signs[idx], pixel_idx)
new_val = (grad_sign / 255. + utils.tuple_getter(example, pixel_idx))
utils.tuple_setter(example, pixel_idx, float(new_val))
new_out = classifier_net.forward(normalizer.forward( \
Variable(example.unsqueeze(0))))
bad_discretization = (int(desired_target) != int(new_out.max(1)[1]))
corrected_imgs.append(example)
# Stack up results
output = []
for idx in range(len(img_tensor)):
if idx in incorrect_idxs:
output.append(corrected_imgs.pop(0))
else:
output.append(og_discretized[idx].data)
return torch.stack(output) # Variable
#############################################################################
# #
# FLIP TECHNIQUES #
# #
#############################################################################
''' Flip techniques in general have the following specs:
ARGS:
classifier_net : NN - neural net with .forward method to classify
normalized images
normalizer : differentiableNormalizer object - normalizes 0,1 images
into classifier_domain
RETURNS: flip_function
'''
'''
Flip function is a function that takes the following args:
ARGS:
img_tensor : Tensor (CxHxW) - image tensor in range 0.0 to 1.0 and is
already discretized
pixels_changed_so_far: set - set of index_tuples that have already been
modified (we don't want to modify a pixel by
more than 1/255 in any channel)
correct_target : torch.LongTensor (1) - single element in a tensor that
is the target class
(e.g. int between 0 and 9 for CIFAR )
RETURNS: (idx_tuple, sign)
index_tuple is a triple of indices indicating which pixel-channel needs
to be modified, and sign is in {-1, 0, 1}. If +-1, we will modify the
pixel-channel in that direction, otherwise we'll modify in the opposite
of the direction that discretization rounded to.
'''
def flip_random_pixel(classifier_net, normalizer):
def flip_fxn(img_tensor, pixels_changed_so_far, correct_target):
numel = img_tensor.numel()
if len(pixels_changed_so_far) > numel * .9:
raise Exception("WHAT IS GOING ON???")
while True:
pixel_idx, _ = utils.random_element_index(img_tensor)
if pixel_idx not in pixels_changed_so_far:
return pixel_idx, 0
return flip_fxn
def flip_greedy_pixel(classifier_net, normalizer):
def flip_fxn(img_tensor, pixels_changed_so_far, correct_target,
classifier_net=classifier_net, normalizer=normalizer):
# Computes gradient and figures out which px most affects class_out
classifier_net.zero_grad()
img_var = Variable(img_tensor.unsqueeze(0), requires_grad=True)
class_out = classifier_net.forward(normalizer.forward(img_var))
criterion = torch.nn.CrossEntropyLoss()
loss = criterion(class_out, correct_target) # RESHAPE HERE
loss.backward()
# Really inefficient algorithm here, can probably do better
new_grad_data = img_var.grad.data.clone().squeeze()
signs = new_grad_data.sign()
for idx_tuple in pixels_changed_so_far:
utils.tuple_setter(new_grad_data, idx_tuple, 0)
argmax = utils.torch_argmax(new_grad_data.abs())
return argmax, -1 * utils.tuple_getter(signs, argmax)
return flip_fxn
| 9,786 | 42.497778 | 103 | py |
DiffPure | DiffPure-master/stadv_eot/recoloradv/mister_ed/utils/pytorch_utils.py | # ---------------------------------------------------------------
# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# This file has been modified from recoloradv.
#
# Source:
# https://github.com/cassidylaidlaw/ReColorAdv/blob/master/recoloradv/mister_ed/utils/pytorch_utils.py
#
# The license for the original version of this file can be
# found in the `recoloradv` directory (LICENSE_RECOLORADV).
# The modifications to this file are subject to the same license.
# ---------------------------------------------------------------
""" Utilities for general pytorch helpfulness """
from __future__ import print_function
import torch
import numpy as np
import torchvision.transforms as transforms
import torch.cuda as cuda
import gc
import os
import warnings
from torch.autograd import Variable, Function
import subprocess
from functools import reduce
###############################################################################
# #
# SAFETY DANCE #
# #
###############################################################################
# aka things for safer pytorch usage
def use_gpu():
""" The shortcut to retrieve the environment variable 'MISTER_ED_GPU'"""
try:
str_val = os.environ['MISTER_ED_GPU']
except:
set_global_gpu()
str_val = os.environ['MISTER_ED_GPU']
assert str_val in ['True', 'False']
return str_val == 'True'
def set_global_gpu(manual=None):
""" Sets the environment variable 'MISTER_ED_GPU'. Defaults to using gpu
if cuda is available
ARGS:
manual : bool - we set the 'MISTER_ED_GPU' environment var to the string
of whatever this is
RETURNS
None
"""
if manual is None:
val = cuda.is_available()
else:
val = manual
os.environ['MISTER_ED_GPU'] = str(val)
def unset_global_gpu():
""" Removes the environment variable 'MISTER_ED_GPU'
# NOTE: this relies on unsetenv, which works on 'most flavors of Unix'
according to the docs
"""
try:
os.unsetenv('MISTER_ED_GPU')
except:
raise Warning("os.unsetenv(.) isn't working properly")
def cuda_assert(use_cuda):
assert not (use_cuda and not cuda.is_available())
def safe_var(entity, **kwargs):
""" Returns a variable of an entity, which may or may not already be a
variable
"""
warnings.warn("As of >=pytorch0.4.0 this is no longer necessary",
DeprecationWarning)
if isinstance(entity, Variable):
return entity
elif isinstance(entity, torch._C._TensorBase):
return Variable(entity, **kwargs)
else:
raise Exception("Can't cast %s to a Variable" %
entity.__class__.__name__)
def safe_tensor(entity):
""" Returns a tensor of an entity, which may or may not already be a
tensor
"""
warnings.warn("As of >=pytorch0.4.0 this is no longer necessary",
DeprecationWarning)
if isinstance(entity, Variable):
return entity.data
elif isinstance(entity, torch.tensor._TensorBase):
return entity
elif isinstance(entity, np.ndarray):
return torch.Tensor(entity) # UNSAFE CUDA CASTING
else:
raise Exception("Can't cast %s to a Variable" %
entity.__class__.__name__)
##############################################################################
# #
# CONVENIENCE STORE #
# #
##############################################################################
# aka convenient things that are not builtin to pytorch
class AverageMeter(object):
"""Computes and stores the average and current value"""
def __init__(self):
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
self.val = val
self.sum += val * n
self.count += n
self.avg = self.sum / self.count
def __str__(self):
return str(self.avg)
def tuple_getter(tensor, idx_tuple):
""" access a tensor by a tuple """
tensor_ = tensor
for el in idx_tuple:
tensor_ = tensor_[el]
return tensor_
def tuple_setter(tensor, idx_tuple, val):
""" Sets a tensor element while indexing by a tuple"""
tensor_ = tensor
for el in idx_tuple[:-1]:
tensor_ = tensor_[el]
tensor_[idx_tuple[-1]] = val
return tensor
def torch_argmax(tensor):
""" Returns the idx tuple that corresponds to the max value in the tensor"""
flat_tensor = tensor.view(tensor.numel())
_, argmax = flat_tensor.max(0)
return np.unravel_index(int(argmax), tensor.shape)
def torch_argmin(tensor):
""" Returns the idx tuple that corresponds to the min value in the tensor"""
flat_tensor = tensor.view(tensor.numel())
_, argmin = flat_tensor.min(0)
return np.unravel_index(int(argmin), tensor.shape)
def clamp_ref(x, y, l_inf):
""" Clamps each element of x to be within l_inf of each element of y """
return torch.clamp(x - y, -l_inf, l_inf) + y
def torch_arctanh(x, eps=1e-6):
x *= (1. - eps)
return (torch.log((1 + x) / (1 - x))) * 0.5
def tanh_rescale(x, x_min=-1., x_max=1.):
return (torch.tanh(x) + 1) * 0.5 * (x_max - x_min) + x_min
def checkpoint_incremental_array(output_file, numpy_list,
return_concat=True):
""" Takes in a string of a filename and a list of numpy arrays and
concatenates them along first axis, saves them to a file, and then
outputs a list containing only that single concatenated array
ARGS:
output_file : string ending in .npy - full path location of the
place we're saving this numpy array
numpy_list : list of numpy arrays (all same shape except for the first
axis) - list of arrays we concat and save to file
return_concat : boolean - if True, we return these concatenated arrays
in a list, else we return nothing
RETURNS:
maybe nothing, maybe the a singleton list containing the concatenated
arrays
"""
concat = np.concatenate(numpy_list, axis=0)
np.save(output_file, concat)
if return_concat:
return [concat]
def sizeof_fmt(num, suffix='B'):
""" https://stackoverflow.com/a/1094933
answer by Sridhar Ratnakumar """
for unit in ['', 'Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei', 'Zi']:
if abs(num) < 1024.0:
return "%3.1f%s%s" % (num, unit, suffix)
num /= 1024.0
return "%.1f%s%s" % (num, 'Yi', suffix)
def clip_0_1(tensorlike):
# Clips tensorlike object into [0., 1.0] range
return torch.clamp(tensorlike, 0.0, 1.0)
def clamp_0_1_delta(x, y):
""" Returns the delta that'd have to be added to (x + y) such that
(x + y) + delta is in the range [0.0, 1.0]
"""
return torch.clamp(x + y, 0.0, 1.0) - (x + y)
def random_linf_pertubation(examples_like, l_inf):
""" Returns an object of the same type/shape as examples_like that holds
a uniformly random pertubation in the l_infinity box of l_inf.
NOTE THAT THIS DOES NOT ADD TO examples_like!
"""
is_var = isinstance(examples_like, Variable)
random_tensor = (torch.rand(*examples_like.shape) * l_inf * 2 -
torch.ones(*examples_like.shape) * l_inf)
random_tensor.type(type(examples_like))
if is_var:
return Variable(random_tensor)
else:
return random_tensor
def batchwise_norm(examples, lp, dim=0):
""" Returns the per-example norm of the examples, keeping along the
specified dimension.
e.g. if examples is NxCxHxW, applying this fxn with dim=0 will return a
N-length tensor with the lp norm of each example
ARGS:
examples : tensor or Variable - needs more than one dimension
lp : string or int - either 'inf' or an int for which lp norm we use
dim : int - which dimension to keep
RETURNS:
1D object of same type as examples, but with shape examples.shape[dim]
"""
assert isinstance(lp, int) or lp == 'inf'
examples = torch.abs(examples)
example_dim = examples.dim()
if dim != 0:
examples = examples.transpose(dim, 0)
if lp == 'inf':
for reduction in range(1, example_dim):
examples, _ = examples.max(1)
return examples
else:
examples = torch.pow(examples + 1e-10, lp)
for reduction in range(1, example_dim):
examples = examples.sum(1)
return torch.pow(examples, 1.0 / lp)
def batchwise_lp_project(x, lp, lp_bound, dim=0):
""" Projects x (a N-by-(...) TENSOR) to be a N-by-(...) TENSOR into the
provided lp ball
ARGS:
x : Tensor (N-by-(...)) - arbitrary style
lp : 'inf' or int - which style of lp we use
lp_bound : float - size of lp ball we project into
dim : int - if not 0 is the dimension we keep and project onto
RETURNS:
None
"""
assert isinstance(lp, int) or lp == 'inf'
if lp == 'inf':
return torch.clamp(x, -lp_bound, lp_bound)
needs_squeeze = False
if len(x.shape) == 1:
x = x.unsqueeze(1)
needs_squeeze = True
output = torch.renorm(x, lp, dim, lp_bound)
if needs_squeeze:
return output.squeeze()
return output
def summed_lp_norm(examples, lp):
""" Returns the sum of the lp norm of each example in examples
ARGS:
examples : tensor or Variable, with first dimension having size N
lp : string or int - either 'inf' or an int for which lp norm we use
RETURNS:
sum of each of the lp norm of each of the N elements in examples
"""
return torch.sum(batchwise_norm(examples, lp, dim=0))
def random_from_lp_ball(tensorlike, lp, lp_bound, dim=0):
""" Returns a new object of the same type/shape as tensorlike that is
randomly samples from the unit ball.
NOTE THIS IS NOT A UNIFORM SAMPLING METHOD!
(that's hard to implement, https://mathoverflow.net/a/9192/123034)
ARGS:
tensorlike : Tensor - reference object for which we generate
a new object of same shape/memory_location
lp : int or 'inf' - which style of lp we use
lp_bound : float - size of the L
dim : int - which dimension is the 'keep dimension'
RETURNS:
new tensorlike where each slice across dim is uniform across the
lp ball of size lp_bound
"""
assert isinstance(lp, int) or lp == 'inf'
rand_direction = torch.rand(tensorlike.shape).type(tensorlike.type())
if lp == 'inf':
return rand_direction * (2 * lp_bound) - lp_bound
else:
rand_direction = rand_direction - 0.5 # allow for sign swapping
# first magnify such that each element is above the ball
min_norm = torch.min(batchwise_norm(rand_direction.abs(), lp, dim=dim))
rand_direction = rand_direction / (min_norm + 1e-6)
rand_magnitudes = torch.rand(tensorlike.shape[dim]).type(
tensorlike.type())
rand_magnitudes = rand_magnitudes.unsqueeze(1)
rand_magnitudes = rand_magnitudes.expand(*rand_direction.shape)
return torch.renorm(rand_direction, lp, dim, lp_bound) * rand_magnitudes
def tanh_transform(tensorlike, forward=True):
""" Takes in Tensor or Variable and converts it between [0, 1] range and
(-inf, +inf) range by performing an invertible tanh transformation.
ARGS:
tensorlike : Tensor or Variable (arbitrary shape) - object to be
modified into or out of tanh space
forward : bool - if True we convert from [0, 1] space to (-inf, +inf)
space
if False we convert from (-inf, +inf) space to [0, 1]
space
RETURNS:
object of the same shape/type as tensorlike, but with the appropriate
transformation
"""
if forward:
assert torch.min(tensorlike) >= 0.0
assert torch.max(tensorlike) <= 1.0
# first convert to [-1, +1] space
temp = (tensorlike * 2 - 1) * (1 - 1e-6)
return torch.log((1 + temp) / (1 - temp)) / 2.0
else:
return (torch.tanh(tensorlike) + 1) / 2.0
def fold_mask(x, y, mask):
""" Creates a new tensor that's the result of masking between x and y
ARGS:
x : Tensor or Variable (NxSHAPE) - tensor that we're selecting where the
masked values are 1
y : Tensor or Variable (NxSHAPE) - tensor that we're selecting where the
masked values are 0
mask: ByteTensor (N) - masked values. Is only one dimensional: we expand
it in the creation of this
RETURNS:
new object of the same shape/type as x and y
"""
assert x.shape == y.shape
assert mask.shape == (x.shape[0],)
assert type(x) == type(y)
is_var = isinstance(x, Variable)
if is_var:
assert isinstance(mask, Variable)
per_example_shape = x.shape[1:]
make_broadcastable = lambda m: m.view(-1, *tuple([1] * (x.dim() - 1)))
broadcast_mask = make_broadcastable(mask)
broadcast_not_mask = make_broadcastable(1 - safe_tensor(mask))
if is_var:
broadcast_not_mask = Variable(broadcast_not_mask)
output = torch.zeros_like(x)
output.add_(x * (broadcast_mask.type(x.type())))
output.add_(y * (broadcast_not_mask.type(y.type())))
return output
###############################################################################
# #
# CUDA RELATED THINGS #
# #
###############################################################################
# fxn taken from https://discuss.pytorch.org/t/memory-leaks-in-trans-conv/12492
def get_gpu_memory_map():
try:
result = subprocess.check_output(
[
'nvidia-smi', '--query-gpu=memory.used',
'--format=csv,nounits,noheader'
])
except:
result = "<CAN'T GET GPU MEM>"
try:
return float(result)
except:
return result
def rough_gpu_estimate():
""" Roughly estimates the size of the cuda tensors stored on GPUs.
If multiple gpus, returns a dict of {GPU_id: total num elements }
otherwise just returns the total number of elements
"""
cuda_count = {}
listprod = lambda l: reduce(lambda x, y: x * y, l)
for el in gc.get_objects():
if isinstance(el, (torch.tensor._TensorBase, Variable)) and el.is_cuda:
device = el.get_device()
cuda_count[device] = (cuda_count.get(device, 0) +
listprod(el.size()))
if len(cuda_count.keys()) == 0:
return 0
elif len(cuda_count.keys()) == 1:
return sizeof_fmt(cuda_count.values()[0])
else:
return {k: sizeof_fmt(v) for k, v in cuda_count.items()}
##############################################################################
# #
# CLASSIFICATION HELPERS #
# #
##############################################################################
# aka little utils that are useful for classification
def accuracy_int(output, target, topk=1):
""" Computes the number of correct examples in the output.
RETURNS an int!
"""
_, pred = output.topk(topk, 1, True, True)
pred = pred.t()
correct = pred.eq(target.view(1, -1).expand_as(pred))
return int(correct.data.sum())
def accuracy(output, target, topk=(1,)):
"""Computes the precision@k for the specified values of k"""
maxk = max(topk)
batch_size = target.size(0)
_, pred = output.topk(maxk, 1, True, True)
pred = pred.t()
correct = pred.eq(target.view(1, -1).expand_as(pred))
res = []
for k in topk:
correct_k = correct[:k].view(-1).float().sum(0)
res.append(correct_k.mul_(100.0 / batch_size))
return res
###############################################################################
# #
# NORMALIZERS #
# #
###############################################################################
class IdentityNormalize(Function):
def __init__(self):
pass
def forward(self, var):
return var
def differentiable_call(self):
pass
class DifferentiableNormalize(Function):
def __init__(self, mean, std):
super(DifferentiableNormalize, self).__init__()
self.mean = mean
self.std = std
self.differentiable = True
self.nondiff_normer = transforms.Normalize(mean, std)
def __call__(self, var):
if self.differentiable:
return self.forward(var)
else:
return self.nondiff_normer(var)
def _setter(self, c, mean, std):
""" Modifies params going forward """
if mean is not None:
self.mean = mean
assert len(self.mean) == c
if std is not None:
self.std = std
assert len(self.std) == c
if mean is not None or std is not None:
self.nondiff_normer = transforms.Normalize(self.mean, self.std)
def differentiable_call(self):
""" Sets the __call__ method to be the differentiable version """
self.differentiable = True
def nondifferentiable_call(self):
""" Sets the __call__ method to be the torchvision.transforms version"""
self.differentiable = False
def forward(self, var, mean=None, std=None):
""" Normalizes var by subtracting the mean of each channel and then
dividing each channel by standard dev
ARGS:
self - stores mean and std for later
var - Variable of shape NxCxHxW
mean - if not None is a list of length C for channel-means
std - if not None is a list of length C for channel-stds
RETURNS:
variable of normalized var
"""
c = var.shape[1]
self._setter(c, mean, std)
mean_var = Variable(var.data.new(self.mean).view(1, c, 1, 1))
std_var = Variable(var.data.new(self.std).view(1, c, 1, 1))
return (var - mean_var) / std_var
##############################################################################
# #
# TRAINING LOGGER #
# #
##############################################################################
class TrainingLogger(object):
def __init__(self):
""" Unified object to keep track of training data at a specified logging
level. Namely this tracks ground accuracy, loss and attack accuracy
for each attack incorporated into adversarial training.
Will ultimately contain plotting techniques too (TODO!)
"""
self.series = {}
def data_count(self):
""" Returns the number of data points in this logger instance """
return sum(len(_) for _ in self.series.values())
def add_series(self, name):
""" Adds the name of a 'data series' where each data series is a list
of data-entries, where each data-entry is of the form
((epoch, minibatch), data-value ) [and data-value is a float]
"""
if name not in self.series:
self.series[name] = []
def sort_series(self, name, return_keys=False):
""" Simply returns the series of specified name sorted by epoch and then
minibatch.
ARGS:
name: string - name of exsiting series in self.series
return_keys: bool - if True, the output list is like
[((epoch, minibatch), val), ...]
and if False, it's just like [val, ... val...]
RETURNS:
sorted list of outputs, the exact form of which is determined by
the value of return_keys
"""
data_series = self.series[name]
sorted_series = sorted(data_series, key=lambda p: p[0])
if return_keys is False:
return [_[1] for _ in sorted_series]
else:
return sorted_series
def get_series(self, name):
""" simple getter method for the given named data series """
return self.series[name]
def log_datapoint(self, name, data_tuple):
""" Logs the full data point
ARGS:
name: string - name of existing series in self.series
data_tuple : tuple of form ((epoch, minibatch), value)
RETURNS:
None
"""
self.series[name].append(data_tuple)
def log(self, name, epoch, minibatch, value):
""" Logs the data point by specifying each of epoch, minibatch, value
ARGS:
name : string - name of existing series in self.series
epoch: int - which epoch of training we're logging
minibatch : int - which minibatch of training we're logging
value : <unspecified, but preferably float> - value we're logging
"""
self.log_datapoint(name, ((epoch, minibatch), value))
| 22,236 | 33.854232 | 102 | py |
DiffPure | DiffPure-master/ddpm/unet_ddpm.py | # ---------------------------------------------------------------
# Taken from the following link as is from:
# https://github.com/ermongroup/SDEdit/blob/main/models/diffusion.py
#
# The license for the original version of this file can be
# found in this directory (LICENSE_UNET_DDPM).
# ---------------------------------------------------------------
import math
import torch
import torch.nn as nn
def get_timestep_embedding(timesteps, embedding_dim):
"""
This matches the implementation in Denoising Diffusion Probabilistic Models:
From Fairseq.
Build sinusoidal embeddings.
This matches the implementation in tensor2tensor, but differs slightly
from the description in Section 3.5 of "Attention Is All You Need".
"""
assert len(timesteps.shape) == 1
half_dim = embedding_dim // 2
emb = math.log(10000) / (half_dim - 1)
emb = torch.exp(torch.arange(half_dim, dtype=torch.float32) * -emb)
emb = emb.to(device=timesteps.device)
emb = timesteps.float()[:, None] * emb[None, :]
emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1)
if embedding_dim % 2 == 1: # zero pad
emb = torch.nn.functional.pad(emb, (0, 1, 0, 0))
return emb
def nonlinearity(x):
# swish
return x * torch.sigmoid(x)
def Normalize(in_channels):
return torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
class Upsample(nn.Module):
def __init__(self, in_channels, with_conv):
super().__init__()
self.with_conv = with_conv
if self.with_conv:
self.conv = torch.nn.Conv2d(in_channels,
in_channels,
kernel_size=3,
stride=1,
padding=1)
def forward(self, x):
x = torch.nn.functional.interpolate(
x, scale_factor=2.0, mode="nearest")
if self.with_conv:
x = self.conv(x)
return x
class Downsample(nn.Module):
def __init__(self, in_channels, with_conv):
super().__init__()
self.with_conv = with_conv
if self.with_conv:
# no asymmetric padding in torch conv, must do it ourselves
self.conv = torch.nn.Conv2d(in_channels,
in_channels,
kernel_size=3,
stride=2,
padding=0)
def forward(self, x):
if self.with_conv:
pad = (0, 1, 0, 1)
x = torch.nn.functional.pad(x, pad, mode="constant", value=0)
x = self.conv(x)
else:
x = torch.nn.functional.avg_pool2d(x, kernel_size=2, stride=2)
return x
class ResnetBlock(nn.Module):
def __init__(self, *, in_channels, out_channels=None, conv_shortcut=False,
dropout, temb_channels=512):
super().__init__()
self.in_channels = in_channels
out_channels = in_channels if out_channels is None else out_channels
self.out_channels = out_channels
self.use_conv_shortcut = conv_shortcut
self.norm1 = Normalize(in_channels)
self.conv1 = torch.nn.Conv2d(in_channels,
out_channels,
kernel_size=3,
stride=1,
padding=1)
self.temb_proj = torch.nn.Linear(temb_channels,
out_channels)
self.norm2 = Normalize(out_channels)
self.dropout = torch.nn.Dropout(dropout)
self.conv2 = torch.nn.Conv2d(out_channels,
out_channels,
kernel_size=3,
stride=1,
padding=1)
if self.in_channels != self.out_channels:
if self.use_conv_shortcut:
self.conv_shortcut = torch.nn.Conv2d(in_channels,
out_channels,
kernel_size=3,
stride=1,
padding=1)
else:
self.nin_shortcut = torch.nn.Conv2d(in_channels,
out_channels,
kernel_size=1,
stride=1,
padding=0)
def forward(self, x, temb):
h = x
h = self.norm1(h)
h = nonlinearity(h)
h = self.conv1(h)
h = h + self.temb_proj(nonlinearity(temb))[:, :, None, None]
h = self.norm2(h)
h = nonlinearity(h)
h = self.dropout(h)
h = self.conv2(h)
if self.in_channels != self.out_channels:
if self.use_conv_shortcut:
x = self.conv_shortcut(x)
else:
x = self.nin_shortcut(x)
return x + h
class AttnBlock(nn.Module):
def __init__(self, in_channels):
super().__init__()
self.in_channels = in_channels
self.norm = Normalize(in_channels)
self.q = torch.nn.Conv2d(in_channels,
in_channels,
kernel_size=1,
stride=1,
padding=0)
self.k = torch.nn.Conv2d(in_channels,
in_channels,
kernel_size=1,
stride=1,
padding=0)
self.v = torch.nn.Conv2d(in_channels,
in_channels,
kernel_size=1,
stride=1,
padding=0)
self.proj_out = torch.nn.Conv2d(in_channels,
in_channels,
kernel_size=1,
stride=1,
padding=0)
def forward(self, x):
h_ = x
h_ = self.norm(h_)
q = self.q(h_)
k = self.k(h_)
v = self.v(h_)
# compute attention
b, c, h, w = q.shape
q = q.reshape(b, c, h * w)
q = q.permute(0, 2, 1) # b,hw,c
k = k.reshape(b, c, h * w) # b,c,hw
w_ = torch.bmm(q, k) # b,hw,hw w[b,i,j]=sum_c q[b,i,c]k[b,c,j]
w_ = w_ * (int(c) ** (-0.5))
w_ = torch.nn.functional.softmax(w_, dim=2)
# attend to values
v = v.reshape(b, c, h * w)
w_ = w_.permute(0, 2, 1) # b,hw,hw (first hw of k, second of q)
# b, c,hw (hw of q) h_[b,c,j] = sum_i v[b,c,i] w_[b,i,j]
h_ = torch.bmm(v, w_)
h_ = h_.reshape(b, c, h, w)
h_ = self.proj_out(h_)
return x + h_
class Model(nn.Module):
def __init__(self, config):
super().__init__()
self.config = config
ch, out_ch, ch_mult = config.model.ch, config.model.out_ch, tuple(config.model.ch_mult)
num_res_blocks = config.model.num_res_blocks
attn_resolutions = config.model.attn_resolutions
dropout = config.model.dropout
in_channels = config.model.in_channels
resolution = config.data.image_size
resamp_with_conv = config.model.resamp_with_conv
self.ch = ch
self.temb_ch = self.ch * 4
self.num_resolutions = len(ch_mult)
self.num_res_blocks = num_res_blocks
self.resolution = resolution
self.in_channels = in_channels
# timestep embedding
self.temb = nn.Module()
self.temb.dense = nn.ModuleList([
torch.nn.Linear(self.ch,
self.temb_ch),
torch.nn.Linear(self.temb_ch,
self.temb_ch),
])
# downsampling
self.conv_in = torch.nn.Conv2d(in_channels,
self.ch,
kernel_size=3,
stride=1,
padding=1)
curr_res = resolution
in_ch_mult = (1,) + ch_mult
self.down = nn.ModuleList()
block_in = None
for i_level in range(self.num_resolutions):
block = nn.ModuleList()
attn = nn.ModuleList()
block_in = ch * in_ch_mult[i_level]
block_out = ch * ch_mult[i_level]
for i_block in range(self.num_res_blocks):
block.append(ResnetBlock(in_channels=block_in,
out_channels=block_out,
temb_channels=self.temb_ch,
dropout=dropout))
block_in = block_out
if curr_res in attn_resolutions:
attn.append(AttnBlock(block_in))
down = nn.Module()
down.block = block
down.attn = attn
if i_level != self.num_resolutions - 1:
down.downsample = Downsample(block_in, resamp_with_conv)
curr_res = curr_res // 2
self.down.append(down)
# middle
self.mid = nn.Module()
self.mid.block_1 = ResnetBlock(in_channels=block_in,
out_channels=block_in,
temb_channels=self.temb_ch,
dropout=dropout)
self.mid.attn_1 = AttnBlock(block_in)
self.mid.block_2 = ResnetBlock(in_channels=block_in,
out_channels=block_in,
temb_channels=self.temb_ch,
dropout=dropout)
# upsampling
self.up = nn.ModuleList()
for i_level in reversed(range(self.num_resolutions)):
block = nn.ModuleList()
attn = nn.ModuleList()
block_out = ch * ch_mult[i_level]
skip_in = ch * ch_mult[i_level]
for i_block in range(self.num_res_blocks + 1):
if i_block == self.num_res_blocks:
skip_in = ch * in_ch_mult[i_level]
block.append(ResnetBlock(in_channels=block_in + skip_in,
out_channels=block_out,
temb_channels=self.temb_ch,
dropout=dropout))
block_in = block_out
if curr_res in attn_resolutions:
attn.append(AttnBlock(block_in))
up = nn.Module()
up.block = block
up.attn = attn
if i_level != 0:
up.upsample = Upsample(block_in, resamp_with_conv)
curr_res = curr_res * 2
self.up.insert(0, up) # prepend to get consistent order
# end
self.norm_out = Normalize(block_in)
self.conv_out = torch.nn.Conv2d(block_in,
out_ch,
kernel_size=3,
stride=1,
padding=1)
def forward(self, x, t):
assert x.shape[2] == x.shape[3] == self.resolution
# timestep embedding
temb = get_timestep_embedding(t, self.ch)
temb = self.temb.dense[0](temb)
temb = nonlinearity(temb)
temb = self.temb.dense[1](temb)
# downsampling
hs = [self.conv_in(x)]
for i_level in range(self.num_resolutions):
for i_block in range(self.num_res_blocks):
h = self.down[i_level].block[i_block](hs[-1], temb)
if len(self.down[i_level].attn) > 0:
h = self.down[i_level].attn[i_block](h)
hs.append(h)
if i_level != self.num_resolutions - 1:
hs.append(self.down[i_level].downsample(hs[-1]))
# middle
h = hs[-1]
h = self.mid.block_1(h, temb)
h = self.mid.attn_1(h)
h = self.mid.block_2(h, temb)
# upsampling
for i_level in reversed(range(self.num_resolutions)):
for i_block in range(self.num_res_blocks + 1):
h = self.up[i_level].block[i_block](
torch.cat([h, hs.pop()], dim=1), temb)
if len(self.up[i_level].attn) > 0:
h = self.up[i_level].attn[i_block](h)
if i_level != 0:
h = self.up[i_level].upsample(h)
# end
h = self.norm_out(h)
h = nonlinearity(h)
h = self.conv_out(h)
return h
| 13,040 | 36.690751 | 95 | py |
DiffPure | DiffPure-master/score_sde/losses.py | # coding=utf-8
# Copyright 2020 The Google Research Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""All functions related to loss computation and optimization.
"""
import torch
import torch.optim as optim
import numpy as np
from .models import utils as mutils
from .sde_lib import VESDE, VPSDE
def get_optimizer(config, params):
"""Returns a flax optimizer object based on `config`."""
if config.optim.optimizer == 'Adam':
optimizer = optim.Adam(params, lr=config.optim.lr, betas=(config.optim.beta1, 0.999), eps=config.optim.eps,
weight_decay=config.optim.weight_decay)
else:
raise NotImplementedError(
f'Optimizer {config.optim.optimizer} not supported yet!')
return optimizer
def optimization_manager(config):
"""Returns an optimize_fn based on `config`."""
def optimize_fn(optimizer, params, step, lr=config.optim.lr,
warmup=config.optim.warmup,
grad_clip=config.optim.grad_clip):
"""Optimizes with warmup and gradient clipping (disabled if negative)."""
if warmup > 0:
for g in optimizer.param_groups:
g['lr'] = lr * np.minimum(step / warmup, 1.0)
if grad_clip >= 0:
torch.nn.utils.clip_grad_norm_(params, max_norm=grad_clip)
optimizer.step()
return optimize_fn
def get_sde_loss_fn(sde, train, reduce_mean=True, continuous=True, likelihood_weighting=True, eps=1e-5):
"""Create a loss function for training with arbirary SDEs.
Args:
sde: An `sde_lib.SDE` object that represents the forward SDE.
train: `True` for training loss and `False` for evaluation loss.
reduce_mean: If `True`, average the loss across data dimensions. Otherwise sum the loss across data dimensions.
continuous: `True` indicates that the model is defined to take continuous time steps. Otherwise it requires
ad-hoc interpolation to take continuous time steps.
likelihood_weighting: If `True`, weight the mixture of score matching losses
according to https://arxiv.org/abs/2101.09258; otherwise use the weighting recommended in our paper.
eps: A `float` number. The smallest time step to sample from.
Returns:
A loss function.
"""
reduce_op = torch.mean if reduce_mean else lambda *args, **kwargs: 0.5 * torch.sum(*args, **kwargs)
def loss_fn(model, batch):
"""Compute the loss function.
Args:
model: A score model.
batch: A mini-batch of training data.
Returns:
loss: A scalar that represents the average loss value across the mini-batch.
"""
score_fn = mutils.get_score_fn(sde, model, train=train, continuous=continuous)
t = torch.rand(batch.shape[0], device=batch.device) * (sde.T - eps) + eps
z = torch.randn_like(batch)
mean, std = sde.marginal_prob(batch, t)
perturbed_data = mean + std[:, None, None, None] * z
score = score_fn(perturbed_data, t)
if not likelihood_weighting:
losses = torch.square(score * std[:, None, None, None] + z)
losses = reduce_op(losses.reshape(losses.shape[0], -1), dim=-1)
else:
g2 = sde.sde(torch.zeros_like(batch), t)[1] ** 2
losses = torch.square(score + z / std[:, None, None, None])
losses = reduce_op(losses.reshape(losses.shape[0], -1), dim=-1) * g2
loss = torch.mean(losses)
return loss
return loss_fn
def get_smld_loss_fn(vesde, train, reduce_mean=False):
"""Legacy code to reproduce previous results on SMLD(NCSN). Not recommended for new work."""
assert isinstance(vesde, VESDE), "SMLD training only works for VESDEs."
# Previous SMLD models assume descending sigmas
smld_sigma_array = torch.flip(vesde.discrete_sigmas, dims=(0,))
reduce_op = torch.mean if reduce_mean else lambda *args, **kwargs: 0.5 * torch.sum(*args, **kwargs)
def loss_fn(model, batch):
model_fn = mutils.get_model_fn(model, train=train)
labels = torch.randint(0, vesde.N, (batch.shape[0],), device=batch.device)
sigmas = smld_sigma_array.to(batch.device)[labels]
noise = torch.randn_like(batch) * sigmas[:, None, None, None]
perturbed_data = noise + batch
score = model_fn(perturbed_data, labels)
target = -noise / (sigmas ** 2)[:, None, None, None]
losses = torch.square(score - target)
losses = reduce_op(losses.reshape(losses.shape[0], -1), dim=-1) * sigmas ** 2
loss = torch.mean(losses)
return loss
return loss_fn
def get_ddpm_loss_fn(vpsde, train, reduce_mean=True):
"""Legacy code to reproduce previous results on DDPM. Not recommended for new work."""
assert isinstance(vpsde, VPSDE), "DDPM training only works for VPSDEs."
reduce_op = torch.mean if reduce_mean else lambda *args, **kwargs: 0.5 * torch.sum(*args, **kwargs)
def loss_fn(model, batch):
model_fn = mutils.get_model_fn(model, train=train)
labels = torch.randint(0, vpsde.N, (batch.shape[0],), device=batch.device)
sqrt_alphas_cumprod = vpsde.sqrt_alphas_cumprod.to(batch.device)
sqrt_1m_alphas_cumprod = vpsde.sqrt_1m_alphas_cumprod.to(batch.device)
noise = torch.randn_like(batch)
perturbed_data = sqrt_alphas_cumprod[labels, None, None, None] * batch + \
sqrt_1m_alphas_cumprod[labels, None, None, None] * noise
score = model_fn(perturbed_data, labels)
losses = torch.square(score - noise)
losses = reduce_op(losses.reshape(losses.shape[0], -1), dim=-1)
loss = torch.mean(losses)
return loss
return loss_fn
def get_step_fn(sde, train, optimize_fn=None, reduce_mean=False, continuous=True, likelihood_weighting=False):
"""Create a one-step training/evaluation function.
Args:
sde: An `sde_lib.SDE` object that represents the forward SDE.
optimize_fn: An optimization function.
reduce_mean: If `True`, average the loss across data dimensions. Otherwise sum the loss across data dimensions.
continuous: `True` indicates that the model is defined to take continuous time steps.
likelihood_weighting: If `True`, weight the mixture of score matching losses according to
https://arxiv.org/abs/2101.09258; otherwise use the weighting recommended by our paper.
Returns:
A one-step function for training or evaluation.
"""
if continuous:
loss_fn = get_sde_loss_fn(sde, train, reduce_mean=reduce_mean,
continuous=True, likelihood_weighting=likelihood_weighting)
else:
assert not likelihood_weighting, "Likelihood weighting is not supported for original SMLD/DDPM training."
if isinstance(sde, VESDE):
loss_fn = get_smld_loss_fn(sde, train, reduce_mean=reduce_mean)
elif isinstance(sde, VPSDE):
loss_fn = get_ddpm_loss_fn(sde, train, reduce_mean=reduce_mean)
else:
raise ValueError(f"Discrete training for {sde.__class__.__name__} is not recommended.")
def step_fn(state, batch):
"""Running one step of training or evaluation.
This function will undergo `jax.lax.scan` so that multiple steps can be pmapped and jit-compiled together
for faster execution.
Args:
state: A dictionary of training information, containing the score model, optimizer,
EMA status, and number of optimization steps.
batch: A mini-batch of training/evaluation data.
Returns:
loss: The average loss value of this state.
"""
model = state['model']
if train:
optimizer = state['optimizer']
optimizer.zero_grad()
loss = loss_fn(model, batch)
loss.backward()
optimize_fn(optimizer, model.parameters(), step=state['step'])
state['step'] += 1
state['ema'].update(model.parameters())
else:
with torch.no_grad():
ema = state['ema']
ema.store(model.parameters())
ema.copy_to(model.parameters())
loss = loss_fn(model, batch)
ema.restore(model.parameters())
return loss
return step_fn
| 8,334 | 38.50237 | 115 | py |
DiffPure | DiffPure-master/score_sde/sampling.py | # coding=utf-8
# Copyright 2020 The Google Research Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: skip-file
# pytype: skip-file
"""Various sampling methods."""
import functools
import torch
import numpy as np
import abc
from .models.utils import from_flattened_numpy, to_flattened_numpy, get_score_fn
from scipy import integrate
from . import sde_lib
from .models import utils as mutils
_CORRECTORS = {}
_PREDICTORS = {}
def register_predictor(cls=None, *, name=None):
"""A decorator for registering predictor classes."""
def _register(cls):
if name is None:
local_name = cls.__name__
else:
local_name = name
if local_name in _PREDICTORS:
raise ValueError(f'Already registered model with name: {local_name}')
_PREDICTORS[local_name] = cls
return cls
if cls is None:
return _register
else:
return _register(cls)
def register_corrector(cls=None, *, name=None):
"""A decorator for registering corrector classes."""
def _register(cls):
if name is None:
local_name = cls.__name__
else:
local_name = name
if local_name in _CORRECTORS:
raise ValueError(f'Already registered model with name: {local_name}')
_CORRECTORS[local_name] = cls
return cls
if cls is None:
return _register
else:
return _register(cls)
def get_predictor(name):
return _PREDICTORS[name]
def get_corrector(name):
return _CORRECTORS[name]
def get_sampling_fn(config, sde, shape, inverse_scaler, eps):
"""Create a sampling function.
Args:
config: A `ml_collections.ConfigDict` object that contains all configuration information.
sde: A `sde_lib.SDE` object that represents the forward SDE.
shape: A sequence of integers representing the expected shape of a single sample.
inverse_scaler: The inverse data normalizer function.
eps: A `float` number. The reverse-time SDE is only integrated to `eps` for numerical stability.
Returns:
A function that takes random states and a replicated training state and outputs samples with the
trailing dimensions matching `shape`.
"""
sampler_name = config.sampling.method
# Probability flow ODE sampling with black-box ODE solvers
if sampler_name.lower() == 'ode':
sampling_fn = get_ode_sampler(sde=sde,
shape=shape,
inverse_scaler=inverse_scaler,
denoise=config.sampling.noise_removal,
eps=eps,
device=config.device)
# Predictor-Corrector sampling. Predictor-only and Corrector-only samplers are special cases.
elif sampler_name.lower() == 'pc':
predictor = get_predictor(config.sampling.predictor.lower())
corrector = get_corrector(config.sampling.corrector.lower())
sampling_fn = get_pc_sampler(sde=sde,
shape=shape,
predictor=predictor,
corrector=corrector,
inverse_scaler=inverse_scaler,
snr=config.sampling.snr,
n_steps=config.sampling.n_steps_each,
probability_flow=config.sampling.probability_flow,
continuous=config.training.continuous,
denoise=config.sampling.noise_removal,
eps=eps,
device=config.device)
else:
raise ValueError(f"Sampler name {sampler_name} unknown.")
return sampling_fn
class Predictor(abc.ABC):
"""The abstract class for a predictor algorithm."""
def __init__(self, sde, score_fn, probability_flow=False):
super().__init__()
self.sde = sde
# Compute the reverse SDE/ODE
self.rsde = sde.reverse(score_fn, probability_flow)
self.score_fn = score_fn
@abc.abstractmethod
def update_fn(self, x, t):
"""One update of the predictor.
Args:
x: A PyTorch tensor representing the current state
t: A Pytorch tensor representing the current time step.
Returns:
x: A PyTorch tensor of the next state.
x_mean: A PyTorch tensor. The next state without random noise. Useful for denoising.
"""
pass
class Corrector(abc.ABC):
"""The abstract class for a corrector algorithm."""
def __init__(self, sde, score_fn, snr, n_steps):
super().__init__()
self.sde = sde
self.score_fn = score_fn
self.snr = snr
self.n_steps = n_steps
@abc.abstractmethod
def update_fn(self, x, t):
"""One update of the corrector.
Args:
x: A PyTorch tensor representing the current state
t: A PyTorch tensor representing the current time step.
Returns:
x: A PyTorch tensor of the next state.
x_mean: A PyTorch tensor. The next state without random noise. Useful for denoising.
"""
pass
@register_predictor(name='euler_maruyama')
class EulerMaruyamaPredictor(Predictor):
def __init__(self, sde, score_fn, probability_flow=False):
super().__init__(sde, score_fn, probability_flow)
def update_fn(self, x, t):
dt = -1. / self.rsde.N
z = torch.randn_like(x)
drift, diffusion = self.rsde.sde(x, t)
x_mean = x + drift * dt
x = x_mean + diffusion[:, None, None, None] * np.sqrt(-dt) * z
return x, x_mean
@register_predictor(name='reverse_diffusion')
class ReverseDiffusionPredictor(Predictor):
def __init__(self, sde, score_fn, probability_flow=False):
super().__init__(sde, score_fn, probability_flow)
def update_fn(self, x, t):
f, G = self.rsde.discretize(x, t)
z = torch.randn_like(x)
x_mean = x - f
x = x_mean + G[:, None, None, None] * z
return x, x_mean
@register_predictor(name='ancestral_sampling')
class AncestralSamplingPredictor(Predictor):
"""The ancestral sampling predictor. Currently only supports VE/VP SDEs."""
def __init__(self, sde, score_fn, probability_flow=False):
super().__init__(sde, score_fn, probability_flow)
if not isinstance(sde, sde_lib.VPSDE) and not isinstance(sde, sde_lib.VESDE):
raise NotImplementedError(f"SDE class {sde.__class__.__name__} not yet supported.")
assert not probability_flow, "Probability flow not supported by ancestral sampling"
def vesde_update_fn(self, x, t):
sde = self.sde
timestep = (t * (sde.N - 1) / sde.T).long()
sigma = sde.discrete_sigmas[timestep]
adjacent_sigma = torch.where(timestep == 0, torch.zeros_like(t), sde.discrete_sigmas.to(t.device)[timestep - 1])
score = self.score_fn(x, t)
x_mean = x + score * (sigma ** 2 - adjacent_sigma ** 2)[:, None, None, None]
std = torch.sqrt((adjacent_sigma ** 2 * (sigma ** 2 - adjacent_sigma ** 2)) / (sigma ** 2))
noise = torch.randn_like(x)
x = x_mean + std[:, None, None, None] * noise
return x, x_mean
def vpsde_update_fn(self, x, t):
sde = self.sde
timestep = (t * (sde.N - 1) / sde.T).long()
beta = sde.discrete_betas.to(t.device)[timestep]
score = self.score_fn(x, t)
x_mean = (x + beta[:, None, None, None] * score) / torch.sqrt(1. - beta)[:, None, None, None]
noise = torch.randn_like(x)
x = x_mean + torch.sqrt(beta)[:, None, None, None] * noise
return x, x_mean
def update_fn(self, x, t):
if isinstance(self.sde, sde_lib.VESDE):
return self.vesde_update_fn(x, t)
elif isinstance(self.sde, sde_lib.VPSDE):
return self.vpsde_update_fn(x, t)
@register_predictor(name='none')
class NonePredictor(Predictor):
"""An empty predictor that does nothing."""
def __init__(self, sde, score_fn, probability_flow=False):
pass
def update_fn(self, x, t):
return x, x
@register_corrector(name='langevin')
class LangevinCorrector(Corrector):
def __init__(self, sde, score_fn, snr, n_steps):
super().__init__(sde, score_fn, snr, n_steps)
if not isinstance(sde, sde_lib.VPSDE) \
and not isinstance(sde, sde_lib.VESDE) \
and not isinstance(sde, sde_lib.subVPSDE):
raise NotImplementedError(f"SDE class {sde.__class__.__name__} not yet supported.")
def update_fn(self, x, t):
sde = self.sde
score_fn = self.score_fn
n_steps = self.n_steps
target_snr = self.snr
if isinstance(sde, sde_lib.VPSDE) or isinstance(sde, sde_lib.subVPSDE):
timestep = (t * (sde.N - 1) / sde.T).long()
alpha = sde.alphas.to(t.device)[timestep]
else:
alpha = torch.ones_like(t)
for i in range(n_steps):
grad = score_fn(x, t)
noise = torch.randn_like(x)
grad_norm = torch.norm(grad.reshape(grad.shape[0], -1), dim=-1).mean()
noise_norm = torch.norm(noise.reshape(noise.shape[0], -1), dim=-1).mean()
step_size = (target_snr * noise_norm / grad_norm) ** 2 * 2 * alpha
x_mean = x + step_size[:, None, None, None] * grad
x = x_mean + torch.sqrt(step_size * 2)[:, None, None, None] * noise
return x, x_mean
@register_corrector(name='ald')
class AnnealedLangevinDynamics(Corrector):
"""The original annealed Langevin dynamics predictor in NCSN/NCSNv2.
We include this corrector only for completeness. It was not directly used in our paper.
"""
def __init__(self, sde, score_fn, snr, n_steps):
super().__init__(sde, score_fn, snr, n_steps)
if not isinstance(sde, sde_lib.VPSDE) \
and not isinstance(sde, sde_lib.VESDE) \
and not isinstance(sde, sde_lib.subVPSDE):
raise NotImplementedError(f"SDE class {sde.__class__.__name__} not yet supported.")
def update_fn(self, x, t):
sde = self.sde
score_fn = self.score_fn
n_steps = self.n_steps
target_snr = self.snr
if isinstance(sde, sde_lib.VPSDE) or isinstance(sde, sde_lib.subVPSDE):
timestep = (t * (sde.N - 1) / sde.T).long()
alpha = sde.alphas.to(t.device)[timestep]
else:
alpha = torch.ones_like(t)
std = self.sde.marginal_prob(x, t)[1]
for i in range(n_steps):
grad = score_fn(x, t)
noise = torch.randn_like(x)
step_size = (target_snr * std) ** 2 * 2 * alpha
x_mean = x + step_size[:, None, None, None] * grad
x = x_mean + noise * torch.sqrt(step_size * 2)[:, None, None, None]
return x, x_mean
@register_corrector(name='none')
class NoneCorrector(Corrector):
"""An empty corrector that does nothing."""
def __init__(self, sde, score_fn, snr, n_steps):
pass
def update_fn(self, x, t):
return x, x
def shared_predictor_update_fn(x, t, sde, model, predictor, probability_flow, continuous):
"""A wrapper that configures and returns the update function of predictors."""
score_fn = mutils.get_score_fn(sde, model, train=False, continuous=continuous)
if predictor is None:
# Corrector-only sampler
predictor_obj = NonePredictor(sde, score_fn, probability_flow)
else:
predictor_obj = predictor(sde, score_fn, probability_flow)
return predictor_obj.update_fn(x, t)
def shared_corrector_update_fn(x, t, sde, model, corrector, continuous, snr, n_steps):
"""A wrapper tha configures and returns the update function of correctors."""
score_fn = mutils.get_score_fn(sde, model, train=False, continuous=continuous)
if corrector is None:
# Predictor-only sampler
corrector_obj = NoneCorrector(sde, score_fn, snr, n_steps)
else:
corrector_obj = corrector(sde, score_fn, snr, n_steps)
return corrector_obj.update_fn(x, t)
def get_pc_sampler(sde, shape, predictor, corrector, inverse_scaler, snr,
n_steps=1, probability_flow=False, continuous=False,
denoise=True, eps=1e-3, device='cuda'):
"""Create a Predictor-Corrector (PC) sampler.
Args:
sde: An `sde_lib.SDE` object representing the forward SDE.
shape: A sequence of integers. The expected shape of a single sample.
predictor: A subclass of `sampling.Predictor` representing the predictor algorithm.
corrector: A subclass of `sampling.Corrector` representing the corrector algorithm.
inverse_scaler: The inverse data normalizer.
snr: A `float` number. The signal-to-noise ratio for configuring correctors.
n_steps: An integer. The number of corrector steps per predictor update.
probability_flow: If `True`, solve the reverse-time probability flow ODE when running the predictor.
continuous: `True` indicates that the score model was continuously trained.
denoise: If `True`, add one-step denoising to the final samples.
eps: A `float` number. The reverse-time SDE and ODE are integrated to `epsilon` to avoid numerical issues.
device: PyTorch device.
Returns:
A sampling function that returns samples and the number of function evaluations during sampling.
"""
# Create predictor & corrector update functions
predictor_update_fn = functools.partial(shared_predictor_update_fn,
sde=sde,
predictor=predictor,
probability_flow=probability_flow,
continuous=continuous)
corrector_update_fn = functools.partial(shared_corrector_update_fn,
sde=sde,
corrector=corrector,
continuous=continuous,
snr=snr,
n_steps=n_steps)
def pc_sampler(model):
""" The PC sampler funciton.
Args:
model: A score model.
Returns:
Samples, number of function evaluations.
"""
with torch.no_grad():
# Initial sample
x = sde.prior_sampling(shape).to(device)
timesteps = torch.linspace(sde.T, eps, sde.N, device=device)
for i in range(sde.N):
t = timesteps[i]
vec_t = torch.ones(shape[0], device=t.device) * t
x, x_mean = corrector_update_fn(x, vec_t, model=model)
x, x_mean = predictor_update_fn(x, vec_t, model=model)
return inverse_scaler(x_mean if denoise else x), sde.N * (n_steps + 1)
return pc_sampler
def get_ode_sampler(sde, shape, inverse_scaler,
denoise=False, rtol=1e-5, atol=1e-5,
method='RK45', eps=1e-3, device='cuda'):
"""Probability flow ODE sampler with the black-box ODE solver.
Args:
sde: An `sde_lib.SDE` object that represents the forward SDE.
shape: A sequence of integers. The expected shape of a single sample.
inverse_scaler: The inverse data normalizer.
denoise: If `True`, add one-step denoising to final samples.
rtol: A `float` number. The relative tolerance level of the ODE solver.
atol: A `float` number. The absolute tolerance level of the ODE solver.
method: A `str`. The algorithm used for the black-box ODE solver.
See the documentation of `scipy.integrate.solve_ivp`.
eps: A `float` number. The reverse-time SDE/ODE will be integrated to `eps` for numerical stability.
device: PyTorch device.
Returns:
A sampling function that returns samples and the number of function evaluations during sampling.
"""
def denoise_update_fn(model, x):
score_fn = get_score_fn(sde, model, train=False, continuous=True)
# Reverse diffusion predictor for denoising
predictor_obj = ReverseDiffusionPredictor(sde, score_fn, probability_flow=False)
vec_eps = torch.ones(x.shape[0], device=x.device) * eps
_, x = predictor_obj.update_fn(x, vec_eps)
return x
def drift_fn(model, x, t):
"""Get the drift function of the reverse-time SDE."""
score_fn = get_score_fn(sde, model, train=False, continuous=True)
rsde = sde.reverse(score_fn, probability_flow=True)
return rsde.sde(x, t)[0]
def ode_sampler(model, z=None):
"""The probability flow ODE sampler with black-box ODE solver.
Args:
model: A score model.
z: If present, generate samples from latent code `z`.
Returns:
samples, number of function evaluations.
"""
with torch.no_grad():
# Initial sample
if z is None:
# If not represent, sample the latent code from the prior distibution of the SDE.
x = sde.prior_sampling(shape).to(device)
else:
x = z
def ode_func(t, x):
x = from_flattened_numpy(x, shape).to(device).type(torch.float32)
vec_t = torch.ones(shape[0], device=x.device) * t
drift = drift_fn(model, x, vec_t)
return to_flattened_numpy(drift)
# Black-box ODE solver for the probability flow ODE
solution = integrate.solve_ivp(ode_func, (sde.T, eps), to_flattened_numpy(x),
rtol=rtol, atol=atol, method=method)
nfe = solution.nfev
x = torch.tensor(solution.y[:, -1]).reshape(shape).to(device).type(torch.float32)
# Denoising is equivalent to running one predictor step without adding noise
if denoise:
x = denoise_update_fn(model, x)
x = inverse_scaler(x)
return x, nfe
return ode_sampler
| 17,567 | 35.148148 | 116 | py |
DiffPure | DiffPure-master/score_sde/sde_lib.py | # ---------------------------------------------------------------
# Taken from the following link as is from:
# https://github.com/yang-song/score_sde_pytorch/blob/main/sde_lib.py
#
# The license for the original version of this file can be
# found in this directory (LICENSE_SCORE_SDE).
# ---------------------------------------------------------------
"""Abstract SDE classes, Reverse SDE, and VE/VP SDEs."""
import abc
import torch
import numpy as np
class SDE(abc.ABC):
"""SDE abstract class. Functions are designed for a mini-batch of inputs."""
def __init__(self, N):
"""Construct an SDE.
Args:
N: number of discretization time steps.
"""
super().__init__()
self.N = N
@property
@abc.abstractmethod
def T(self):
"""End time of the SDE."""
pass
@abc.abstractmethod
def sde(self, x, t):
pass
@abc.abstractmethod
def marginal_prob(self, x, t):
"""Parameters to determine the marginal distribution of the SDE, $p_t(x)$."""
pass
@abc.abstractmethod
def prior_sampling(self, shape):
"""Generate one sample from the prior distribution, $p_T(x)$."""
pass
@abc.abstractmethod
def prior_logp(self, z):
"""Compute log-density of the prior distribution.
Useful for computing the log-likelihood via probability flow ODE.
Args:
z: latent code
Returns:
log probability density
"""
pass
def discretize(self, x, t):
"""Discretize the SDE in the form: x_{i+1} = x_i + f_i(x_i) + G_i z_i.
Useful for reverse diffusion sampling and probabiliy flow sampling.
Defaults to Euler-Maruyama discretization.
Args:
x: a torch tensor
t: a torch float representing the time step (from 0 to `self.T`)
Returns:
f, G
"""
dt = 1 / self.N
drift, diffusion = self.sde(x, t)
f = drift * dt
G = diffusion * torch.sqrt(torch.tensor(dt, device=t.device))
return f, G
def reverse(self, score_fn, probability_flow=False):
"""Create the reverse-time SDE/ODE.
Args:
score_fn: A time-dependent score-based model that takes x and t and returns the score.
probability_flow: If `True`, create the reverse-time ODE used for probability flow sampling.
"""
N = self.N
T = self.T
sde_fn = self.sde
discretize_fn = self.discretize
# Build the class for reverse-time SDE.
class RSDE(self.__class__):
def __init__(self):
self.N = N
self.probability_flow = probability_flow
@property
def T(self):
return T
def sde(self, x, t):
"""Create the drift and diffusion functions for the reverse SDE/ODE."""
drift, diffusion = sde_fn(x, t)
score = score_fn(x, t)
drift = drift - diffusion[:, None, None, None] ** 2 * score * (0.5 if self.probability_flow else 1.)
# Set the diffusion function to zero for ODEs.
diffusion = 0. if self.probability_flow else diffusion
return drift, diffusion
def discretize(self, x, t):
"""Create discretized iteration rules for the reverse diffusion sampler."""
f, G = discretize_fn(x, t)
rev_f = f - G[:, None, None, None] ** 2 * score_fn(x, t) * (0.5 if self.probability_flow else 1.)
rev_G = torch.zeros_like(G) if self.probability_flow else G
return rev_f, rev_G
return RSDE()
class VPSDE(SDE):
def __init__(self, beta_min=0.1, beta_max=20, N=1000):
"""Construct a Variance Preserving SDE.
Args:
beta_min: value of beta(0)
beta_max: value of beta(1)
N: number of discretization steps
"""
super().__init__(N)
self.beta_0 = beta_min
self.beta_1 = beta_max
self.N = N
self.discrete_betas = torch.linspace(beta_min / N, beta_max / N, N)
self.alphas = 1. - self.discrete_betas
self.alphas_cumprod = torch.cumprod(self.alphas, dim=0)
self.sqrt_alphas_cumprod = torch.sqrt(self.alphas_cumprod)
self.sqrt_1m_alphas_cumprod = torch.sqrt(1. - self.alphas_cumprod)
@property
def T(self):
return 1
def sde(self, x, t):
beta_t = self.beta_0 + t * (self.beta_1 - self.beta_0)
drift = -0.5 * beta_t[:, None, None, None] * x
diffusion = torch.sqrt(beta_t)
return drift, diffusion
def marginal_prob(self, x, t):
log_mean_coeff = -0.25 * t ** 2 * (self.beta_1 - self.beta_0) - 0.5 * t * self.beta_0
mean = torch.exp(log_mean_coeff[:, None, None, None]) * x
std = torch.sqrt(1. - torch.exp(2. * log_mean_coeff))
return mean, std
def prior_sampling(self, shape):
return torch.randn(*shape)
def prior_logp(self, z):
shape = z.shape
N = np.prod(shape[1:])
logps = -N / 2. * np.log(2 * np.pi) - torch.sum(z ** 2, dim=(1, 2, 3)) / 2.
return logps
def discretize(self, x, t):
"""DDPM discretization."""
timestep = (t * (self.N - 1) / self.T).long()
beta = self.discrete_betas.to(x.device)[timestep]
alpha = self.alphas.to(x.device)[timestep]
sqrt_beta = torch.sqrt(beta)
f = torch.sqrt(alpha)[:, None, None, None] * x - x
G = sqrt_beta
return f, G
class subVPSDE(SDE):
def __init__(self, beta_min=0.1, beta_max=20, N=1000):
"""Construct the sub-VP SDE that excels at likelihoods.
Args:
beta_min: value of beta(0)
beta_max: value of beta(1)
N: number of discretization steps
"""
super().__init__(N)
self.beta_0 = beta_min
self.beta_1 = beta_max
self.N = N
@property
def T(self):
return 1
def sde(self, x, t):
beta_t = self.beta_0 + t * (self.beta_1 - self.beta_0)
drift = -0.5 * beta_t[:, None, None, None] * x
discount = 1. - torch.exp(-2 * self.beta_0 * t - (self.beta_1 - self.beta_0) * t ** 2)
diffusion = torch.sqrt(beta_t * discount)
return drift, diffusion
def marginal_prob(self, x, t):
log_mean_coeff = -0.25 * t ** 2 * (self.beta_1 - self.beta_0) - 0.5 * t * self.beta_0
mean = torch.exp(log_mean_coeff)[:, None, None, None] * x
std = 1 - torch.exp(2. * log_mean_coeff)
return mean, std
def prior_sampling(self, shape):
return torch.randn(*shape)
def prior_logp(self, z):
shape = z.shape
N = np.prod(shape[1:])
return -N / 2. * np.log(2 * np.pi) - torch.sum(z ** 2, dim=(1, 2, 3)) / 2.
class VESDE(SDE):
def __init__(self, sigma_min=0.01, sigma_max=50, N=1000):
"""Construct a Variance Exploding SDE.
Args:
sigma_min: smallest sigma.
sigma_max: largest sigma.
N: number of discretization steps
"""
super().__init__(N)
self.sigma_min = sigma_min
self.sigma_max = sigma_max
self.discrete_sigmas = torch.exp(torch.linspace(np.log(self.sigma_min), np.log(self.sigma_max), N))
self.N = N
@property
def T(self):
return 1
def sde(self, x, t):
sigma = self.sigma_min * (self.sigma_max / self.sigma_min) ** t
drift = torch.zeros_like(x)
diffusion = sigma * torch.sqrt(torch.tensor(2 * (np.log(self.sigma_max) - np.log(self.sigma_min)),
device=t.device))
return drift, diffusion
def marginal_prob(self, x, t):
std = self.sigma_min * (self.sigma_max / self.sigma_min) ** t
mean = x
return mean, std
def prior_sampling(self, shape):
return torch.randn(*shape) * self.sigma_max
def prior_logp(self, z):
shape = z.shape
N = np.prod(shape[1:])
return -N / 2. * np.log(2 * np.pi * self.sigma_max ** 2) - torch.sum(z ** 2, dim=(1, 2, 3)) / (2 * self.sigma_max ** 2)
def discretize(self, x, t):
"""SMLD(NCSN) discretization."""
timestep = (t * (self.N - 1) / self.T).long()
sigma = self.discrete_sigmas.to(t.device)[timestep]
adjacent_sigma = torch.where(timestep == 0, torch.zeros_like(t),
self.discrete_sigmas[timestep - 1].to(t.device))
f = torch.zeros_like(x)
G = torch.sqrt(sigma ** 2 - adjacent_sigma ** 2)
return f, G | 7,909 | 29.19084 | 123 | py |
DiffPure | DiffPure-master/score_sde/models/up_or_down_sampling.py | # ---------------------------------------------------------------
# Taken from the following link as is from:
# https://github.com/yang-song/score_sde_pytorch/blob/main/models/up_or_down_sampling.py
#
# The license for the original version of this file can be
# found in the `score_sde` directory (LICENSE_SCORE_SDE).
# ---------------------------------------------------------------
"""Layers used for up-sampling or down-sampling images.
Many functions are ported from https://github.com/NVlabs/stylegan2.
"""
import torch.nn as nn
import torch
import torch.nn.functional as F
import numpy as np
from ..op import upfirdn2d
# Function ported from StyleGAN2
def get_weight(module,
shape,
weight_var='weight',
kernel_init=None):
"""Get/create weight tensor for a convolution or fully-connected layer."""
return module.param(weight_var, kernel_init, shape)
class Conv2d(nn.Module):
"""Conv2d layer with optimal upsampling and downsampling (StyleGAN2)."""
def __init__(self, in_ch, out_ch, kernel, up=False, down=False,
resample_kernel=(1, 3, 3, 1),
use_bias=True,
kernel_init=None):
super().__init__()
assert not (up and down)
assert kernel >= 1 and kernel % 2 == 1
self.weight = nn.Parameter(torch.zeros(out_ch, in_ch, kernel, kernel))
if kernel_init is not None:
self.weight.data = kernel_init(self.weight.data.shape)
if use_bias:
self.bias = nn.Parameter(torch.zeros(out_ch))
self.up = up
self.down = down
self.resample_kernel = resample_kernel
self.kernel = kernel
self.use_bias = use_bias
def forward(self, x):
if self.up:
x = upsample_conv_2d(x, self.weight, k=self.resample_kernel)
elif self.down:
x = conv_downsample_2d(x, self.weight, k=self.resample_kernel)
else:
x = F.conv2d(x, self.weight, stride=1, padding=self.kernel // 2)
if self.use_bias:
x = x + self.bias.reshape(1, -1, 1, 1)
return x
def naive_upsample_2d(x, factor=2):
_N, C, H, W = x.shape
x = torch.reshape(x, (-1, C, H, 1, W, 1))
x = x.repeat(1, 1, 1, factor, 1, factor)
return torch.reshape(x, (-1, C, H * factor, W * factor))
def naive_downsample_2d(x, factor=2):
_N, C, H, W = x.shape
x = torch.reshape(x, (-1, C, H // factor, factor, W // factor, factor))
return torch.mean(x, dim=(3, 5))
def upsample_conv_2d(x, w, k=None, factor=2, gain=1):
"""Fused `upsample_2d()` followed by `tf.nn.conv2d()`.
Padding is performed only once at the beginning, not between the
operations.
The fused op is considerably more efficient than performing the same
calculation
using standard TensorFlow ops. It supports gradients of arbitrary order.
Args:
x: Input tensor of the shape `[N, C, H, W]` or `[N, H, W,
C]`.
w: Weight tensor of the shape `[filterH, filterW, inChannels,
outChannels]`. Grouped convolution can be performed by `inChannels =
x.shape[0] // numGroups`.
k: FIR filter of the shape `[firH, firW]` or `[firN]`
(separable). The default is `[1] * factor`, which corresponds to
nearest-neighbor upsampling.
factor: Integer upsampling factor (default: 2).
gain: Scaling factor for signal magnitude (default: 1.0).
Returns:
Tensor of the shape `[N, C, H * factor, W * factor]` or
`[N, H * factor, W * factor, C]`, and same datatype as `x`.
"""
assert isinstance(factor, int) and factor >= 1
# Check weight shape.
assert len(w.shape) == 4
convH = w.shape[2]
convW = w.shape[3]
inC = w.shape[1]
outC = w.shape[0]
assert convW == convH
# Setup filter kernel.
if k is None:
k = [1] * factor
k = _setup_kernel(k) * (gain * (factor ** 2))
p = (k.shape[0] - factor) - (convW - 1)
stride = (factor, factor)
# Determine data dimensions.
stride = [1, 1, factor, factor]
output_shape = ((_shape(x, 2) - 1) * factor + convH, (_shape(x, 3) - 1) * factor + convW)
output_padding = (output_shape[0] - (_shape(x, 2) - 1) * stride[0] - convH,
output_shape[1] - (_shape(x, 3) - 1) * stride[1] - convW)
assert output_padding[0] >= 0 and output_padding[1] >= 0
num_groups = _shape(x, 1) // inC
# Transpose weights.
w = torch.reshape(w, (num_groups, -1, inC, convH, convW))
w = w[..., ::-1, ::-1].permute(0, 2, 1, 3, 4)
w = torch.reshape(w, (num_groups * inC, -1, convH, convW))
x = F.conv_transpose2d(x, w, stride=stride, output_padding=output_padding, padding=0)
## Original TF code.
# x = tf.nn.conv2d_transpose(
# x,
# w,
# output_shape=output_shape,
# strides=stride,
# padding='VALID',
# data_format=data_format)
## JAX equivalent
return upfirdn2d(x, torch.tensor(k, device=x.device),
pad=((p + 1) // 2 + factor - 1, p // 2 + 1))
def conv_downsample_2d(x, w, k=None, factor=2, gain=1):
"""Fused `tf.nn.conv2d()` followed by `downsample_2d()`.
Padding is performed only once at the beginning, not between the operations.
The fused op is considerably more efficient than performing the same
calculation
using standard TensorFlow ops. It supports gradients of arbitrary order.
Args:
x: Input tensor of the shape `[N, C, H, W]` or `[N, H, W,
C]`.
w: Weight tensor of the shape `[filterH, filterW, inChannels,
outChannels]`. Grouped convolution can be performed by `inChannels =
x.shape[0] // numGroups`.
k: FIR filter of the shape `[firH, firW]` or `[firN]`
(separable). The default is `[1] * factor`, which corresponds to
average pooling.
factor: Integer downsampling factor (default: 2).
gain: Scaling factor for signal magnitude (default: 1.0).
Returns:
Tensor of the shape `[N, C, H // factor, W // factor]` or
`[N, H // factor, W // factor, C]`, and same datatype as `x`.
"""
assert isinstance(factor, int) and factor >= 1
_outC, _inC, convH, convW = w.shape
assert convW == convH
if k is None:
k = [1] * factor
k = _setup_kernel(k) * gain
p = (k.shape[0] - factor) + (convW - 1)
s = [factor, factor]
x = upfirdn2d(x, torch.tensor(k, device=x.device),
pad=((p + 1) // 2, p // 2))
return F.conv2d(x, w, stride=s, padding=0)
def _setup_kernel(k):
k = np.asarray(k, dtype=np.float32)
if k.ndim == 1:
k = np.outer(k, k)
k /= np.sum(k)
assert k.ndim == 2
assert k.shape[0] == k.shape[1]
return k
def _shape(x, dim):
return x.shape[dim]
def upsample_2d(x, k=None, factor=2, gain=1):
r"""Upsample a batch of 2D images with the given filter.
Accepts a batch of 2D images of the shape `[N, C, H, W]` or `[N, H, W, C]`
and upsamples each image with the given filter. The filter is normalized so
that
if the input pixels are constant, they will be scaled by the specified
`gain`.
Pixels outside the image are assumed to be zero, and the filter is padded
with
zeros so that its shape is a multiple of the upsampling factor.
Args:
x: Input tensor of the shape `[N, C, H, W]` or `[N, H, W,
C]`.
k: FIR filter of the shape `[firH, firW]` or `[firN]`
(separable). The default is `[1] * factor`, which corresponds to
nearest-neighbor upsampling.
factor: Integer upsampling factor (default: 2).
gain: Scaling factor for signal magnitude (default: 1.0).
Returns:
Tensor of the shape `[N, C, H * factor, W * factor]`
"""
assert isinstance(factor, int) and factor >= 1
if k is None:
k = [1] * factor
k = _setup_kernel(k) * (gain * (factor ** 2))
p = k.shape[0] - factor
return upfirdn2d(x, torch.tensor(k, device=x.device),
up=factor, pad=((p + 1) // 2 + factor - 1, p // 2))
def downsample_2d(x, k=None, factor=2, gain=1):
r"""Downsample a batch of 2D images with the given filter.
Accepts a batch of 2D images of the shape `[N, C, H, W]` or `[N, H, W, C]`
and downsamples each image with the given filter. The filter is normalized
so that
if the input pixels are constant, they will be scaled by the specified
`gain`.
Pixels outside the image are assumed to be zero, and the filter is padded
with
zeros so that its shape is a multiple of the downsampling factor.
Args:
x: Input tensor of the shape `[N, C, H, W]` or `[N, H, W,
C]`.
k: FIR filter of the shape `[firH, firW]` or `[firN]`
(separable). The default is `[1] * factor`, which corresponds to
average pooling.
factor: Integer downsampling factor (default: 2).
gain: Scaling factor for signal magnitude (default: 1.0).
Returns:
Tensor of the shape `[N, C, H // factor, W // factor]`
"""
assert isinstance(factor, int) and factor >= 1
if k is None:
k = [1] * factor
k = _setup_kernel(k) * gain
p = k.shape[0] - factor
return upfirdn2d(x, torch.tensor(k, device=x.device),
down=factor, pad=((p + 1) // 2, p // 2))
| 9,287 | 33.917293 | 91 | py |
DiffPure | DiffPure-master/score_sde/models/utils.py | # coding=utf-8
# Copyright 2020 The Google Research Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""All functions and modules related to model definition.
"""
import torch
from score_sde import sde_lib
import numpy as np
_MODELS = {}
def register_model(cls=None, *, name=None):
"""A decorator for registering model classes."""
def _register(cls):
if name is None:
local_name = cls.__name__
else:
local_name = name
if local_name in _MODELS:
raise ValueError(f'Already registered model with name: {local_name}')
_MODELS[local_name] = cls
return cls
if cls is None:
return _register
else:
return _register(cls)
def get_model(name):
return _MODELS[name]
def get_sigmas(config):
"""Get sigmas --- the set of noise levels for SMLD from config files.
Args:
config: A ConfigDict object parsed from the config file
Returns:
sigmas: a jax numpy arrary of noise levels
"""
sigmas = np.exp(
np.linspace(np.log(config.model.sigma_max), np.log(config.model.sigma_min), config.model.num_scales))
return sigmas
def get_ddpm_params(config):
"""Get betas and alphas --- parameters used in the original DDPM paper."""
num_diffusion_timesteps = 1000
# parameters need to be adapted if number of time steps differs from 1000
beta_start = config.model.beta_min / config.model.num_scales
beta_end = config.model.beta_max / config.model.num_scales
betas = np.linspace(beta_start, beta_end, num_diffusion_timesteps, dtype=np.float64)
alphas = 1. - betas
alphas_cumprod = np.cumprod(alphas, axis=0)
sqrt_alphas_cumprod = np.sqrt(alphas_cumprod)
sqrt_1m_alphas_cumprod = np.sqrt(1. - alphas_cumprod)
return {
'betas': betas,
'alphas': alphas,
'alphas_cumprod': alphas_cumprod,
'sqrt_alphas_cumprod': sqrt_alphas_cumprod,
'sqrt_1m_alphas_cumprod': sqrt_1m_alphas_cumprod,
'beta_min': beta_start * (num_diffusion_timesteps - 1),
'beta_max': beta_end * (num_diffusion_timesteps - 1),
'num_diffusion_timesteps': num_diffusion_timesteps
}
def create_model(config):
"""Create the score model."""
model_name = config.model.name
score_model = get_model(model_name)(config)
# score_model = score_model.to(config.device)
# score_model = torch.nn.DataParallel(score_model)
return score_model
def get_model_fn(model, train=False):
"""Create a function to give the output of the score-based model.
Args:
model: The score model.
train: `True` for training and `False` for evaluation.
Returns:
A model function.
"""
def model_fn(x, labels):
"""Compute the output of the score-based model.
Args:
x: A mini-batch of input data.
labels: A mini-batch of conditioning variables for time steps. Should be interpreted differently
for different models.
Returns:
A tuple of (model output, new mutable states)
"""
if not train:
model.eval()
return model(x, labels)
else:
model.train()
return model(x, labels)
return model_fn
def get_score_fn(sde, model, train=False, continuous=False):
"""Wraps `score_fn` so that the model output corresponds to a real time-dependent score function.
Args:
sde: An `sde_lib.SDE` object that represents the forward SDE.
model: A score model.
train: `True` for training and `False` for evaluation.
continuous: If `True`, the score-based model is expected to directly take continuous time steps.
Returns:
A score function.
"""
model_fn = get_model_fn(model, train=train)
if isinstance(sde, sde_lib.VPSDE) or isinstance(sde, sde_lib.subVPSDE):
def score_fn(x, t):
# Scale neural network output by standard deviation and flip sign
if continuous or isinstance(sde, sde_lib.subVPSDE):
# For VP-trained models, t=0 corresponds to the lowest noise level
# The maximum value of time embedding is assumed to 999 for
# continuously-trained models.
labels = t * 999
score = model_fn(x, labels)
std = sde.marginal_prob(torch.zeros_like(x), t)[1]
else:
# For VP-trained models, t=0 corresponds to the lowest noise level
labels = t * (sde.N - 1)
score = model_fn(x, labels)
std = sde.sqrt_1m_alphas_cumprod.to(labels.device)[labels.long()]
score = -score / std[:, None, None, None]
return score
elif isinstance(sde, sde_lib.VESDE):
def score_fn(x, t):
if continuous:
labels = sde.marginal_prob(torch.zeros_like(x), t)[1]
else:
# For VE-trained models, t=0 corresponds to the highest noise level
labels = sde.T - t
labels *= sde.N - 1
labels = torch.round(labels).long()
score = model_fn(x, labels)
return score
else:
raise NotImplementedError(f"SDE class {sde.__class__.__name__} not yet supported.")
return score_fn
def to_flattened_numpy(x):
"""Flatten a torch tensor `x` and convert it to numpy."""
return x.detach().cpu().numpy().reshape((-1,))
def from_flattened_numpy(x, shape):
"""Form a torch tensor with the given `shape` from a flattened numpy array `x`."""
return torch.from_numpy(x.reshape(shape))
| 6,151 | 31.723404 | 109 | py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.