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 |
|---|---|---|---|---|---|---|
torch-adaptive-imle | torch-adaptive-imle-main/tests/nri/test_mst.py | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
import os
import sys
import torch
from torch import Tensor
import numpy as np
from nri.utils import maybe_make_logits_symmetric, map_estimator
from imle.aimle import aimle
from imle.ste import ste
from imle.target import TargetDistribution, AdaptiveTargetDistribution
from imle.noise import BaseNoiseDistribution, SumOfGammaNoiseDistribution, GumbelNoiseDistribution
from tqdm import tqdm
import pytest
import logging
logger = logging.getLogger(os.path.basename(sys.argv[0]))
def to_matrix(nb_nodes, flat):
A_out = np.zeros(shape=(nb_nodes, nb_nodes))
counter = 0
flat = flat.view(-1)
for i in range(A_out.shape[0]):
for j in range(A_out.shape[1]):
if i != j:
A_out[i, j] = flat[counter]
counter = counter + 1
return A_out
def _test_nri_v1(nb_iterations: int):
A = np.array([
[0, 8, 5, 0, 0],
[8, 0, 9, 11, 0],
[5, 9, 0, 15, 10],
[0, 11, 15, 0, 7],
[0, 0, 10, 7, 0]
])
A_nodiag = A[~np.eye(A.shape[0], dtype=bool)].reshape(A.shape[0], -1)
logits = torch.tensor(A_nodiag, requires_grad=False, dtype=torch.float).view(1, -1, 1)
logits = maybe_make_logits_symmetric(logits, True)
print(to_matrix(A.shape[0], logits))
noise_distribution = SumOfGammaNoiseDistribution(k=A.shape[0], nb_iterations=10, device=logits.device)
target_distribution = TargetDistribution(alpha=1.0, beta=10.0)
@aimle(target_distribution=target_distribution,
noise_distribution=noise_distribution,
nb_samples=nb_iterations,
theta_noise_temperature=0.0,
target_noise_temperature=0.0,
symmetric_perturbation=False)
def differentiable_map_estimator(logits_: Tensor) -> Tensor:
return map_estimator(logits_, True)
res = differentiable_map_estimator(logits)
res = res.mean(dim=0, keepdim=True)
res_flat = res.view(-1)
A_out = to_matrix(A.shape[0], res_flat)
# It's the example in here: https://www.baeldung.com/java-spanning-trees-kruskal
gold = np.array(
[[0, 1, 0, 0, 0],
[1, 0, 0, 1, 0],
[0, 0, 0, 1, 1],
[0, 1, 1, 0, 0],
[0, 0, 1, 0, 0]])
assert np.sum(np.abs(A_out - gold)) < 1e-12
def test_nri_v1():
for nb_iterations in tqdm(range(100)):
nb_iterations = nb_iterations + 1
for _ in range(8):
_test_nri_v1(nb_iterations)
if __name__ == '__main__':
pytest.main([__file__])
# test_nri_v1()
# test_imle_v1c()
# test_imle_v3a()
| 2,602 | 25.561224 | 106 | py |
torch-adaptive-imle | torch-adaptive-imle-main/imle/target.py | # -*- coding: utf-8 -*-
import torch
from torch import Tensor
from abc import ABC, abstractmethod
from typing import Optional
import logging
logger = logging.getLogger(__name__)
class BaseTargetDistribution(ABC):
def __init__(self):
super().__init__()
@abstractmethod
def params(self,
theta: Tensor,
dy: Optional[Tensor],
_is_minimization: bool = False) -> Tensor:
raise NotImplementedError
@abstractmethod
def process(self,
theta: Tensor,
dy: Tensor,
gradient: Tensor) -> Tensor:
return gradient
class TargetDistribution(BaseTargetDistribution):
r"""
Creates a generator of target distributions parameterized by :attr:`alpha` and :attr:`beta`.
Example::
>>> import torch
>>> target_distribution = TargetDistribution(alpha=1.0, beta=1.0)
>>> target_distribution.params(theta=torch.tensor([1.0]), dy=torch.tensor([1.0]))
tensor([2.])
Args:
alpha (float): weight of the initial distribution parameters theta
beta (float): weight of the downstream gradient dy
do_gradient_scaling (bool): whether to scale the gradient by 1/λ or not
"""
def __init__(self,
alpha: float = 1.0,
beta: float = 1.0,
do_gradient_scaling: bool = False,
eps: float = 1e-7):
super().__init__()
self.alpha = alpha
self.beta = beta
self.do_gradient_scaling = do_gradient_scaling
self.eps = eps
def params(self,
theta: Tensor,
dy: Optional[Tensor],
alpha: Optional[float] = None,
beta: Optional[float] = None,
_is_minimization: bool = False) -> Tensor:
alpha_ = self.alpha if alpha is None else alpha
beta_ = self.beta if beta is None else beta
if _is_minimization is True:
theta_prime = alpha_ * theta + beta_ * (dy if dy is not None else 0.0)
else:
theta_prime = alpha_ * theta - beta_ * (dy if dy is not None else 0.0)
return theta_prime
def process(self,
theta: Tensor,
dy: Tensor,
gradient_3d: Tensor) -> Tensor:
scaling_factor = max(self.beta, self.eps)
res = (gradient_3d / scaling_factor) if self.do_gradient_scaling is True else gradient_3d
return res
class AdaptiveTargetDistribution(BaseTargetDistribution):
def __init__(self,
initial_alpha: float = 1.0,
initial_beta: float = 1.0,
initial_grad_norm: float = 1.0,
# Pitch: the initial default hyperparams lead to very stable results,
# competitive with manually tuned ones -- E.g. try with 1e-3 for this hyperparam
beta_update_step: float = 0.0001,
beta_update_momentum: float = 0.0,
grad_norm_decay_rate: float = 0.9,
target_norm: float = 1.0):
super().__init__()
self.alpha = initial_alpha
self.beta = initial_beta
self.grad_norm = initial_grad_norm
self.beta_update_step = beta_update_step
self.beta_update_momentum = beta_update_momentum
self.previous_beta_update = 0.0
self.grad_norm_decay_rate = grad_norm_decay_rate
self.target_norm = target_norm
def _perturbation_magnitude(self,
theta: Tensor,
dy: Optional[Tensor]):
norm_dy = torch.linalg.norm(dy).item() if dy is not None else 1.0
return 0.0 if norm_dy <= 0.0 else self.beta * (torch.linalg.norm(theta) / norm_dy)
def params(self,
theta: Tensor,
dy: Optional[Tensor],
_is_minimization: bool = False) -> Tensor:
pm = self._perturbation_magnitude(theta, dy)
if _is_minimization is True:
theta_prime = self.alpha * theta + pm * (dy if dy is not None else 0.0)
else:
theta_prime = self.alpha * theta - pm * (dy if dy is not None else 0.0)
return theta_prime
def process(self,
theta: Tensor,
dy: Tensor,
gradient_3d: Tensor) -> Tensor:
batch_size = gradient_3d.shape[0]
nb_samples = gradient_3d.shape[1]
pm = self._perturbation_magnitude(theta, dy)
# We compute an exponentially decaying sum of the gradient norms
grad_nnz = torch.count_nonzero(gradient_3d).float()
nb_gradients = batch_size * nb_samples
# print('GRAD', gradient_3d.shape, 'GRAD NNZ', grad_nnz, batch_size, nb_samples, grad_nnz / nb_gradients)
# print(gradient_3d[0, 0].int())
# Running estimate of the gradient norm (number of non-zero elements for every sample)
self.grad_norm = self.grad_norm_decay_rate * self.grad_norm + \
(1.0 - self.grad_norm_decay_rate) * (grad_nnz / nb_gradients)
# If the gradient norm is lower than 1, we increase beta; otherwise, we decrease beta.
beta_update_ = (1.0 if self.grad_norm.item() < self.target_norm else - 1.0) * self.beta_update_step
beta_update = (self.beta_update_momentum * self.previous_beta_update) + beta_update_
# Enforcing \beta \geq 0
self.beta = max(self.beta + beta_update, 0.0)
self.previous_beta_update = beta_update
# print(f'Gradient norm: {self.grad_norm:.5f}\tBeta: {self.beta:.5f}')
res = gradient_3d / (pm if pm > 0.0 else 1.0)
return res
| 5,674 | 35.612903 | 113 | py |
torch-adaptive-imle | torch-adaptive-imle-main/imle/aimle.py | # -*- coding: utf-8 -*-
import functools
import torch
from torch import Tensor
from imle.noise import BaseNoiseDistribution
from imle.target import BaseTargetDistribution, TargetDistribution
from typing import Callable, Optional
import logging
logger = logging.getLogger(__name__)
def aimle(function: Optional[Callable[[Tensor], Tensor]] = None,
target_distribution: Optional[BaseTargetDistribution] = None,
noise_distribution: Optional[BaseNoiseDistribution] = None,
nb_samples: int = 1,
nb_marginal_samples: int = 1,
theta_noise_temperature: float = 1.0,
target_noise_temperature: float = 1.0,
symmetric_perturbation: bool = False,
_is_minimization: bool = False):
r"""Turns a black-box combinatorial solver in an Exponential Family distribution via Perturb-and-MAP and I-MLE [1].
The theta function (solver) needs to return the solution to the problem of finding a MAP state for a constrained
exponential family distribution -- this is the case for most black-box combinatorial solvers [2]. If this condition
is violated though, the result would not hold and there is no guarantee on the validity of the obtained gradients.
This function can be used directly or as a decorator.
[1] Mathias Niepert, Pasquale Minervini, Luca Franceschi - Implicit MLE: Backpropagating Through Discrete
Exponential Family Distributions. NeurIPS 2021 (https://arxiv.org/abs/2106.01798)
[2] Marin Vlastelica, Anselm Paulus, Vít Musil, Georg Martius, Michal Rolínek - Differentiation of Blackbox
Combinatorial Solvers. ICLR 2020 (https://arxiv.org/abs/1912.02175)
Example::
>>> from imle.aimle import aimle
>>> from imle.target import TargetDistribution
>>> from imle.noise import SumOfGammaNoiseDistribution
>>> target_distribution = TargetDistribution(alpha=0.0, beta=10.0)
>>> noise_distribution = SumOfGammaNoiseDistribution(k=21, nb_iterations=100)
>>> @aimle(target_distribution=target_distribution, noise_distribution=noise_distribution, nb_samples=100,
>>> theta_noise_temperature=theta_noise_temperature, target_noise_temperature=5.0)
>>> def aimle_solver(weights_batch: Tensor) -> Tensor:
>>> return torch_solver(weights_batch)
Args:
function (Callable[[Tensor], Tensor]): black-box combinatorial solver
target_distribution (Optional[BaseTargetDistribution]): factory for target distributions
noise_distribution (Optional[BaseNoiseDistribution]): noise distribution
nb_samples (int): number of noise samples
nb_marginal_samples (int): number of noise samples used to compute the marginals
theta_noise_temperature (float): noise temperature for the theta distribution
target_noise_temperature (float): noise temperature for the target distribution
symmetric_perturbation (bool): whether it uses the symmetric version of IMLE
_is_minimization (bool): whether MAP is solving an argmin problem
"""
if target_distribution is None:
target_distribution = TargetDistribution(alpha=1.0, beta=1.0)
if function is None:
return functools.partial(aimle,
target_distribution=target_distribution,
noise_distribution=noise_distribution,
nb_samples=nb_samples,
nb_marginal_samples=nb_marginal_samples,
theta_noise_temperature=theta_noise_temperature,
target_noise_temperature=target_noise_temperature,
symmetric_perturbation=symmetric_perturbation,
_is_minimization=_is_minimization)
@functools.wraps(function)
def wrapper(theta: Tensor, *args):
class WrappedFunc(torch.autograd.Function):
@staticmethod
def forward(ctx, theta: Tensor, *args):
# [BATCH_SIZE, ...]
theta_shape = theta.shape
batch_size = theta_shape[0]
instance_shape = theta_shape[1:]
nb_total_samples = nb_samples * nb_marginal_samples
# [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
perturbed_theta_shape = [batch_size, nb_total_samples] + list(instance_shape)
# ε ∼ ρ(ε)
# [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
if noise_distribution is None:
noise = torch.zeros(size=torch.Size(perturbed_theta_shape), device=theta.device)
else:
noise = noise_distribution.sample(shape=torch.Size(perturbed_theta_shape)).to(theta.device)
# [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
eps = noise * theta_noise_temperature
# [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
perturbed_theta_3d = theta.view(batch_size, 1, -1).repeat(1, nb_total_samples, 1).view(perturbed_theta_shape)
perturbed_theta_3d = perturbed_theta_3d + eps
# [BATCH_SIZE * N_TOTAL_SAMPLES, ...]
perturbed_theta_2d = perturbed_theta_3d.view([-1] + perturbed_theta_shape[2:])
perturbed_theta_2d_shape = perturbed_theta_2d.shape
assert perturbed_theta_2d_shape[0] == batch_size * nb_total_samples
# z = MAP(θ + ε)
# [BATCH_SIZE * N_TOTAL_SAMPLES, ...]
z_2d = function(perturbed_theta_2d)
assert z_2d.shape == perturbed_theta_2d_shape
# [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
z_3d = z_2d.view(perturbed_theta_shape)
ctx.save_for_backward(theta, noise, z_3d)
# [BATCH_SIZE * N_TOTAL_SAMPLES, ...]
return z_2d
@staticmethod
def backward(ctx, dy):
# theta: [BATCH_SIZE, ...]
# noise: [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
# z_3d: [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
theta, noise, z_3d = ctx.saved_tensors
nb_total_samples = nb_samples * nb_marginal_samples
assert noise.shape[1] == nb_total_samples
theta_shape = theta.shape
instance_shape = theta_shape[1:]
batch_size = theta_shape[0]
# dy is [BATCH_SIZE * N_TOTAL_SAMPLES, ...]
dy_shape = dy.shape
# noise is [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
noise_shape = noise.shape
assert noise_shape == z_3d.shape
# [BATCH_SIZE * NB_SAMPLES, ...]
theta_2d = theta.view(batch_size, 1, -1).repeat(1, nb_total_samples, 1).view(dy_shape)
# θ'_R = θ - λ dy
target_theta_r_2d = target_distribution.params(theta_2d, dy,
_is_minimization=_is_minimization)
# θ'_L = θ + λ dy -- if symmetric_perturbation is False, then this reduces to θ'_L = θ
target_theta_l_2d = target_distribution.params(theta_2d, - dy if symmetric_perturbation else None,
_is_minimization=_is_minimization)
# [BATCH_SIZE, NB_SAMPLES, ...]
target_theta_r_3d = target_theta_r_2d.view(noise_shape)
target_theta_l_3d = target_theta_l_2d.view(noise_shape)
# [BATCH_SIZE, NB_SAMPLES, ...]
eps = noise * target_noise_temperature
# [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
perturbed_target_theta_r_3d = target_theta_r_3d + eps
perturbed_target_theta_l_3d = target_theta_l_3d + eps
# [BATCH_SIZE * N_TOTAL_SAMPLES, ...]
perturbed_target_theta_r_2d = perturbed_target_theta_r_3d.view(dy_shape)
perturbed_target_theta_l_2d = perturbed_target_theta_l_3d.view(dy_shape)
# [BATCH_SIZE * N_TOTAL_SAMPLES, ...]
with torch.inference_mode():
# z'_R = MAP(θ'_R + ε)
z_r_2d = function(perturbed_target_theta_r_2d)
# z'_L = MAP(θ'_L + ε)
z_l_2d = function(perturbed_target_theta_l_2d)
# [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
z_r_3d = z_r_2d.view(noise_shape)
z_l_3d = z_l_2d.view(noise_shape)
if nb_marginal_samples > 1:
assert batch_size == z_l_3d.shape[0] == z_r_3d.shape[0]
assert nb_total_samples == z_l_3d.shape[1] == z_r_3d.shape[1]
# [BATCH_SIZE, N_SAMPLES, N_MARGINAL_SAMPLES, ...]
z_l_4d = z_l_3d.view([batch_size, nb_samples, nb_marginal_samples] + list(instance_shape))
z_r_4d = z_r_3d.view([batch_size, nb_samples, nb_marginal_samples] + list(instance_shape))
z_l_3d = torch.mean(z_l_4d, dim=2)
z_r_3d = torch.mean(z_r_4d, dim=2)
# g = z'_L - z'_R
# Note that if symmetric_perturbation is False, then z'_L = z
# [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
gradient_3d = z_l_3d - z_r_3d
if symmetric_perturbation is True:
gradient_3d = gradient_3d / 2.0
# [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
gradient_3d = target_distribution.process(theta, dy, gradient_3d)
# [BATCH_SIZE, ...]
gradient = gradient_3d.mean(dim=1)
return (- gradient) if _is_minimization is True else gradient
return WrappedFunc.apply(theta, *args)
return wrapper
| 9,870 | 45.126168 | 125 | py |
torch-adaptive-imle | torch-adaptive-imle-main/imle/sfe.py | # -*- coding: utf-8 -*-
import functools
import torch
from torch import Tensor
from imle.noise import BaseNoiseDistribution
from typing import Optional, Callable
import logging
logger = logging.getLogger(__name__)
def sfe(function: Optional[Callable[[Tensor], Tensor]] = None,
noise_distribution: Optional[BaseNoiseDistribution] = None,
noise_temperature: float = 1.0):
if function is None:
return functools.partial(sfe,
noise_distribution=noise_distribution,
noise_temperature=noise_temperature)
@functools.wraps(function)
def wrapper(theta: Tensor, *args):
class WrappedFunc(torch.autograd.Function):
@staticmethod
def forward(ctx, theta: Tensor, *args):
# [BATCH_SIZE, ...]
theta_shape = theta.shape
# ε ∼ ρ(ε)
if noise_distribution is None:
noise = torch.zeros(size=theta_shape, device=theta.device)
else:
noise = noise_distribution.sample(shape=torch.Size(theta_shape)).to(theta.device)
# [BATCH_SIZE, N_SAMPLES, ...]
eps = noise * noise_temperature
perturbed_theta = theta + eps
# z = f(θ)
# [BATCH_SIZE, ...]
z = function(perturbed_theta)
assert z.shape == theta.shape
return z
@staticmethod
def backward(ctx, dy):
# Reminder: ∇θ 𝔼[ f(z) ] = 𝔼ₚ₍z;θ₎ [ f(z) ∇θ log p(z;θ) ]
return dy
return WrappedFunc.apply(theta, *args)
return wrapper
| 1,712 | 27.55 | 101 | py |
torch-adaptive-imle | torch-adaptive-imle-main/imle/imle.py | # -*- coding: utf-8 -*-
import functools
import torch
from torch import Tensor
from imle.noise import BaseNoiseDistribution
from imle.target import BaseTargetDistribution, TargetDistribution
from typing import Optional, Callable
import logging
logger = logging.getLogger(__name__)
def imle(function: Optional[Callable[[Tensor], Tensor]] = None,
target_distribution: Optional[BaseTargetDistribution] = None,
noise_distribution: Optional[BaseNoiseDistribution] = None,
nb_samples: int = 1,
nb_marginal_samples: int = 1,
theta_noise_temperature: float = 1.0,
target_noise_temperature: float = 1.0,
_gradient_save_path: Optional[str] = None,
_is_minimization: bool = False):
r"""Turns a black-box combinatorial solver in an Exponential Family distribution via Perturb-and-MAP and I-MLE [1].
The input function (solver) needs to return the solution to the problem of finding a MAP state for a constrained
exponential family distribution -- this is the case for most black-box combinatorial solvers [2]. If this condition
is violated though, the result would not hold and there is no guarantee on the validity of the obtained gradients.
This function can be used directly or as a decorator.
[1] Mathias Niepert, Pasquale Minervini, Luca Franceschi - Implicit MLE: Backpropagating Through Discrete
Exponential Family Distributions. NeurIPS 2021 (https://arxiv.org/abs/2106.01798)
[2] Marin Vlastelica, Anselm Paulus, Vít Musil, Georg Martius, Michal Rolínek - Differentiation of Blackbox
Combinatorial Solvers. ICLR 2020 (https://arxiv.org/abs/1912.02175)
Example:
>>> from imle.imle import imle
>>> from imle.target import TargetDistribution
>>> from imle.noise import SumOfGammaNoiseDistribution
>>> from imle.solvers import select_k
>>> target_distribution = TargetDistribution(alpha=0.0, beta=10.0)
>>> noise_distribution = SumOfGammaNoiseDistribution(k=21, nb_iterations=100)
>>> @imle(target_distribution=target_distribution, noise_distribution=noise_distribution, nb_samples=100,
>>> theta_noise_temperature=theta_noise_temperature, target_noise_temperature=5.0)
>>> def imle_select_k(weights_batch: Tensor) -> Tensor:
>>> return select_k(weights_batch, k=10)
Args:
function (Callable[[Tensor], Tensor]): black-box combinatorial solver
target_distribution (Optional[BaseTargetDistribution]): factory for target distributions
noise_distribution (Optional[BaseNoiseDistribution]): noise distribution
nb_samples (int): number of noise samples
nb_marginal_samples (int): number of noise samples used to compute the marginals
theta_noise_temperature (float): noise temperature for the input distribution
target_noise_temperature (float): noise temperature for the target distribution
_gradient_save_path (Optional[str]): save the gradient in a numpy tensor at this path
_is_minimization (bool): whether MAP is solving an argmin problem
"""
if target_distribution is None:
target_distribution = TargetDistribution(alpha=1.0, beta=1.0)
if function is None:
return functools.partial(imle,
target_distribution=target_distribution,
noise_distribution=noise_distribution,
nb_samples=nb_samples,
nb_marginal_samples=nb_marginal_samples,
theta_noise_temperature=theta_noise_temperature,
target_noise_temperature=target_noise_temperature,
_gradient_save_path=_gradient_save_path,
_is_minimization=_is_minimization)
@functools.wraps(function)
def wrapper(theta: Tensor, *args):
class WrappedFunc(torch.autograd.Function):
@staticmethod
def forward(ctx, theta: Tensor, *args):
# [BATCH_SIZE, ...]
theta_shape = theta.shape
batch_size = theta_shape[0]
instance_shape = theta_shape[1:]
nb_total_samples = nb_samples * nb_marginal_samples
# [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
perturbed_theta_shape = [batch_size, nb_total_samples] + list(instance_shape)
# ε ∼ ρ(ε)
if noise_distribution is None:
noise = torch.zeros(size=perturbed_theta_shape, device=theta.device)
else:
noise = noise_distribution.sample(shape=torch.Size(perturbed_theta_shape)).to(theta.device)
# [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
eps = noise * theta_noise_temperature
# [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
perturbed_theta_3d = theta.view(batch_size, 1, -1).repeat(1, nb_total_samples, 1).view(perturbed_theta_shape)
perturbed_theta_3d = perturbed_theta_3d + eps
# [BATCH_SIZE * N_TOTAL_SAMPLES, ...]
perturbed_theta_2d = perturbed_theta_3d.view([-1] + perturbed_theta_shape[2:])
perturbed_theta_2d_shape = perturbed_theta_2d.shape
assert perturbed_theta_2d_shape[0] == batch_size * nb_total_samples
# z = MAP(θ + ε)
# [BATCH_SIZE * N_TOTAL_SAMPLES, ...]
z_2d = function(perturbed_theta_2d)
assert z_2d.shape == perturbed_theta_2d_shape
# [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
z_3d = z_2d.view(perturbed_theta_shape)
ctx.save_for_backward(theta, noise, z_3d)
# [BATCH_SIZE * N_TOTAL_SAMPLES, ...]
return z_2d
@staticmethod
def backward(ctx, dy):
# theta: [BATCH_SIZE, ...]
# noise: [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
# z_3d: [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
theta, noise, z_3d = ctx.saved_tensors
nb_total_samples = nb_samples * nb_marginal_samples
assert noise.shape[1] == nb_total_samples
theta_shape = theta.shape
instance_shape = theta_shape[1:]
batch_size = theta_shape[0]
# dy is [BATCH_SIZE * N_TOTAL_SAMPLES, ...]
dy_shape = dy.shape
# noise is [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
noise_shape = noise.shape
assert noise_shape == z_3d.shape
# [BATCH_SIZE * N_TOTAL_SAMPLES, ...]
theta_2d = theta.view(batch_size, 1, -1).repeat(1, nb_total_samples, 1).view(dy_shape)
# θ' = θ - λ dy
target_theta_2d = target_distribution.params(theta_2d, dy, _is_minimization=_is_minimization)
# [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
target_theta_3d = target_theta_2d.view(noise_shape)
# [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
eps = noise * target_noise_temperature
# [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
perturbed_target_theta_3d = target_theta_3d + eps
# [BATCH_SIZE * N_TOTAL_SAMPLES, ...]
perturbed_target_theta_2d = perturbed_target_theta_3d.view(dy_shape)
with torch.inference_mode():
# z' = MAP(θ' + ε)
# [BATCH_SIZE * N_TOTAL_SAMPLES, ...]
z_prime_2d = function(perturbed_target_theta_2d)
# [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
z_prime_3d = z_prime_2d.view(noise_shape)
if nb_marginal_samples > 1:
assert batch_size == z_3d.shape[0] == z_prime_3d.shape[0]
assert nb_total_samples == z_3d.shape[1] == z_prime_3d.shape[1]
# [BATCH_SIZE, N_SAMPLES, N_MARGINAL_SAMPLES, ...]
z_4d = z_3d.view([batch_size, nb_samples, nb_marginal_samples] + list(instance_shape))
z_prime_4d = z_prime_3d.view([batch_size, nb_samples, nb_marginal_samples] + list(instance_shape))
z_3d = torch.mean(z_4d, dim=2)
z_prime_3d = torch.mean(z_prime_4d, dim=2)
# g = z - z'
# [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
gradient_3d = (z_3d - z_prime_3d)
# [BATCH_SIZE, N_TOTAL_SAMPLES, ...]
gradient_3d = target_distribution.process(theta, dy, gradient_3d)
if _gradient_save_path is not None:
import numpy as np
with open(_gradient_save_path, 'wb') as f:
np.save(f, gradient_3d.detach().cpu().numpy())
# [BATCH_SIZE, ...]
gradient = gradient_3d.mean(dim=1)
return (- gradient) if _is_minimization is True else gradient
return WrappedFunc.apply(theta, *args)
return wrapper
| 9,141 | 43.595122 | 125 | py |
torch-adaptive-imle | torch-adaptive-imle-main/imle/noise.py | # -*- coding: utf-8 -*-
import math
import torch
from torch import Tensor, Size
from torch.distributions.gamma import Gamma
from torch.distributions.gumbel import Gumbel
from abc import ABC, abstractmethod
from typing import Optional
import logging
logger = logging.getLogger(__name__)
class BaseNoiseDistribution(ABC):
def __init__(self):
super().__init__()
@abstractmethod
def sample(self,
shape: Size) -> Tensor:
raise NotImplementedError
class SumOfGammaNoiseDistribution(BaseNoiseDistribution):
r"""
Creates a generator of samples for the Sum-of-Gamma distribution [1], parameterized
by :attr:`k`, :attr:`nb_iterations`, and :attr:`device`.
[1] Mathias Niepert, Pasquale Minervini, Luca Franceschi - Implicit MLE: Backpropagating Through Discrete
Exponential Family Distributions. NeurIPS 2021 (https://arxiv.org/abs/2106.01798)
Example::
>>> import torch
>>> noise_distribution = SumOfGammaNoiseDistribution(k=5, nb_iterations=100)
>>> noise_distribution.sample(torch.Size([5]))
tensor([ 0.2504, 0.0112, 0.5466, 0.0051, -0.1497])
Args:
k (float): k parameter -- see [1] for more details.
nb_iterations (int): number of iterations for estimating the sample.
device (torch.devicde): device where to store samples.
"""
def __init__(self,
k: float,
nb_iterations: int = 10,
device: Optional[torch.device] = None):
super().__init__()
self.k = k
self.nb_iterations = nb_iterations
self.device = device
def sample(self,
shape: Size) -> Tensor:
samples = torch.zeros(size=shape, dtype=torch.float, device=self.device)
for i in range(1, self.nb_iterations + 1):
concentration = torch.tensor(1. / self.k, dtype=torch.float, device=self.device)
rate = torch.tensor(i / self.k, dtype=torch.float, device=self.device)
gamma = Gamma(concentration=concentration, rate=rate)
samples = samples + gamma.sample(sample_shape=shape).to(self.device)
samples = (samples - math.log(self.nb_iterations)) / self.k
return samples.to(self.device)
class GumbelNoiseDistribution(BaseNoiseDistribution):
def __init__(self,
location: float = 0.0,
scale: float = 1.0,
device: Optional[torch.device] = None):
super().__init__()
self.location = torch.tensor(location, dtype=torch.float, device=device)
self.scale = torch.tensor(scale, dtype=torch.float, device=device)
self.device = device
self.distribution = Gumbel(loc=self.location, scale=self.scale)
def sample(self,
shape: Size) -> Tensor:
return self.distribution.sample(sample_shape=shape).to(self.device)
| 2,899 | 31.954545 | 109 | py |
torch-adaptive-imle | torch-adaptive-imle-main/imle/solvers.py | # -*- coding: utf-8 -*-
import torch
from torch import Tensor
import logging
logger = logging.getLogger(__name__)
def select_k(logits: Tensor, k: int) -> Tensor:
scores, indices = torch.topk(logits, k, sorted=True)
mask = torch.zeros_like(logits, device=logits.device).scatter_(-1, indices, 1.0)
return mask
def mathias_select_k(logits: Tensor, k: int) -> Tensor:
scores, indices = torch.topk(logits, k, sorted=True)
thr_2d = scores[:, -1].view(-1, 1)
return (logits >= thr_2d).float()
| 517 | 23.666667 | 84 | py |
torch-adaptive-imle | torch-adaptive-imle-main/imle/ste.py | # -*- coding: utf-8 -*-
import functools
import torch
from torch import Tensor
from imle.noise import BaseNoiseDistribution
from typing import Optional, Callable
import logging
logger = logging.getLogger(__name__)
def ste(function: Optional[Callable[[Tensor], Tensor]] = None,
noise_distribution: Optional[BaseNoiseDistribution] = None,
noise_temperature: float = 1.0,
nb_samples: int = 1):
r"""Straight-Through Estimator [1]
[1] Yoshua Bengio, Nicholas Léonard, Aaron C. Courville - Estimating or Propagating Gradients Through
Stochastic Neurons for Conditional Computation. CoRR abs/1308.3432 (2013)
Example:
>>> from imle.ste import ste
>>> from imle.target import TargetDistribution
>>> from imle.noise import SumOfGammaNoiseDistribution
>>> from imle.solvers import select_k
>>> noise_distribution = SumOfGammaNoiseDistribution(k=21, nb_iterations=100)
>>> @ste(noise_distribution=noise_distribution, nb_samples=100, noise_temperature=noise_temperature)
>>> def imle_select_k(weights_batch: Tensor) -> Tensor:
>>> return select_k(weights_batch, k=10)
Args:
function (Callable[[Tensor], Tensor]): black-box combinatorial solver
noise_distribution (Optional[BaseNoiseDistribution]): noise distribution
nb_samples (int): number of noise samples
noise_temperature (float): noise temperature for the input distribution
"""
if function is None:
return functools.partial(ste,
noise_distribution=noise_distribution,
noise_temperature=noise_temperature,
nb_samples=nb_samples)
@functools.wraps(function)
def wrapper(theta: Tensor, *args):
class WrappedFunc(torch.autograd.Function):
@staticmethod
def forward(ctx, theta: Tensor, *args):
# [BATCH_SIZE, ...]
theta_shape = theta.shape
batch_size = theta_shape[0]
instance_shape = theta_shape[1:]
# [BATCH_SIZE, N_SAMPLES, ...]
perturbed_theta_shape = [batch_size, nb_samples] + list(instance_shape)
# ε ∼ ρ(ε)
if noise_distribution is None:
noise = torch.zeros(size=perturbed_theta_shape, device=theta.device)
else:
noise = noise_distribution.sample(shape=torch.Size(perturbed_theta_shape)).to(theta.device)
# [BATCH_SIZE, N_SAMPLES, ...]
eps = noise * noise_temperature
# perturbed_theta = theta + eps
# [BATCH_SIZE, N_SAMPLES, ...]
perturbed_theta_3d = theta.view(batch_size, 1, -1).repeat(1, nb_samples, 1).view(perturbed_theta_shape)
perturbed_theta_3d = perturbed_theta_3d + eps
# [BATCH_SIZE * N_SAMPLES, ...]
perturbed_theta_2d = perturbed_theta_3d.view([-1] + perturbed_theta_shape[2:])
perturbed_theta_2d_shape = perturbed_theta_2d.shape
assert perturbed_theta_2d_shape[0] == batch_size * nb_samples
# z = f(θ)
# [BATCH_SIZE, ...]
# z = function(perturbed_theta)
# assert z.shape == theta.shape
# [BATCH_SIZE * N_SAMPLES, ...]
z_2d = function(perturbed_theta_2d)
assert z_2d.shape == perturbed_theta_2d_shape
ctx.save_for_backward(theta, noise)
return z_2d
@staticmethod
def backward(ctx, dy):
# res = dy
# theta: [BATCH_SIZE, ...]
# noise: [BATCH_SIZE, N_SAMPLES, ...]
theta, noise = ctx.saved_tensors
batch_size = theta.shape[0]
assert batch_size == noise.shape[0]
nb_samples = noise.shape[1]
gradient_shape = dy.shape[1:]
# [BATCH_SIZE, N_SAMPLES, ...]
dy_3d_shape = [batch_size, nb_samples] + list(gradient_shape)
dy_3d = dy.view(dy_3d_shape)
# [BATCH_SIZE, ...]
res = dy_3d.mean(1)
return res
return WrappedFunc.apply(theta, *args)
return wrapper
| 4,385 | 34.95082 | 119 | py |
torch-adaptive-imle | torch-adaptive-imle-main/experiments/generate_nri_aimle_cmd.py | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
import itertools
import os
import os.path
import sys
import logging
def cartesian_product(dicts):
return (dict(zip(dicts, x)) for x in itertools.product(*dicts.values()))
def summary(configuration):
res = configuration['ckp'].split('/')[-1] + '_' + str(configuration['seed'])
return res
def to_cmd(c, _path=None):
command = f'{c["cmd"]} --experiments_folder {c["ckp"]}_{c["seed"]} --seed {c["seed"]}'
if '--timesteps 10' in command:
assert 'T10' in c["ckp"]
elif '--timesteps 20' in command:
assert 'T20' in c["ckp"]
else:
assert False
assert '--hard True' in command
if '_sym_' in c["ckp"]:
assert '--aimle-symmetric' in command
elif '_nosym_' in c["ckp"]:
assert '--aimle-symmetric' not in command
else:
assert False, 'Symmetric or not?'
if 'aimle-target adaptive' in command:
assert '/aimle_' in c["ckp"]
if 'aimle-target standard' in command:
assert '/imle_' in c["ckp"] or '/sst_' in c["ckp"]
if '--method aimle' in command:
assert 'imle_' in c["ckp"]
if '--method sst' in command:
assert 'sst_' in c["ckp"]
assert ('--method aimle' in command) != ('--method sst' in command)
return command
def to_logfile(c, path):
outfile = "{}/nribest_beaker_v3.{}.log".format(path, summary(c).replace("/", "_"))
return outfile
def main(argv):
hyp_space_aimle_sym_10 = dict(
cmd=['PYTHONPATH=. python3 ./cli/torch-nri-cli.py --suffix _novar_1skip_10t_1r_graph10 --timesteps 10 '
'--prediction_steps 9 --sst tree --relaxation exp_family_entropy --max_range 15 --symmeterize_logits True '
'--lr 0.0005 --temp 0.1 --eps_for_finitediff 1.0 --cuda True '
'--experiments_folder ../exp_nri/nri_T=10_bu=0.001_eps=1.0_hard=True_imle_samples=1_lmbda=0.0_lr=0.0005_method=aimle_noise=sog_noise_temp=0.1_scaling=False_sst=tree_symmetric=True_target=adaptive_temp=0.1 '
'--use_cpp_for_sampling True --method aimle --imle-lambda 0.0 --imle-lambda-update-step 0.001 --imle-noise sog '
'--imle-noise-temperature 0.1 --aimle-symmetric --aimle-target adaptive --imle-samples 1 --hard True --st True'],
seed=[0, 1, 2, 3, 4, 5, 6, 7],
ckp=['../exp_nri/aimle_v3_T10_sym_best']
)
hyp_space_aimle_nosym_10 = dict(
cmd=['PYTHONPATH=. python3 ./cli/torch-nri-cli.py --suffix _novar_1skip_10t_1r_graph10 --timesteps 10 '
'--prediction_steps 9 --sst tree --relaxation exp_family_entropy --max_range 15 --symmeterize_logits True '
'--lr 0.0001 --temp 0.1 --eps_for_finitediff 1.0 --cuda True '
'--experiments_folder ../exp_nri/nri_T=10_bu=0.001_eps=1.0_hard=True_imle_samples=1_lmbda=0.0_lr=0.0001_method=aimle_noise=sog_noise_temp=1.0_scaling=False_sst=tree_symmetric=False_target=adaptive_temp=0.1 '
'--use_cpp_for_sampling True --method aimle --imle-lambda 0.0 --imle-lambda-update-step 0.001 --imle-noise sog '
'--imle-noise-temperature 1.0 --aimle-target adaptive --imle-samples 1 --hard True --st True'],
seed=[0, 1, 2, 3, 4, 5, 6, 7],
ckp=['../exp_nri/aimle_v3_T10_nosym_best']
)
hyp_space_aimle_sym_20 = dict(
cmd=['PYTHONPATH=. python3 ./cli/torch-nri-cli.py --suffix _novar_1skip_20t_1r_graph10 --timesteps 20 '
'--prediction_steps 10 --sst tree --relaxation exp_family_entropy --max_range 15 --symmeterize_logits True '
'--lr 0.0005 --temp 0.1 --eps_for_finitediff 1.0 --cuda True '
'--experiments_folder ../exp_nri/nri_T=20_bu=0.001_eps=1.0_hard=True_imle_samples=1_lmbda=0.0_lr=0.0005_method=aimle_noise=sog_noise_temp=1.0_scaling=False_sst=tree_symmetric=True_target=adaptive_temp=0.1 '
'--use_cpp_for_sampling True --method aimle --imle-lambda 0.0 --imle-lambda-update-step 0.001 --imle-noise sog '
'--imle-noise-temperature 1.0 --aimle-symmetric --aimle-target adaptive --imle-samples 1 --hard True --st True'],
seed=[0, 1, 2, 3, 4, 5, 6, 7],
ckp=['../exp_nri/aimle_v3_T20_sym_best']
)
hyp_space_aimle_nosym_20 = dict(
cmd=['PYTHONPATH=. python3 ./cli/torch-nri-cli.py --suffix _novar_1skip_20t_1r_graph10 --timesteps 20 '
'--prediction_steps 10 --sst tree --relaxation exp_family_entropy --max_range 15 --symmeterize_logits True '
'--lr 0.0005 --temp 0.1 --eps_for_finitediff 1.0 --cuda True '
'--experiments_folder ../exp_nri/nri_T=20_bu=0.001_eps=1.0_hard=True_imle_samples=1_lmbda=0.0_lr=0.0005_method=aimle_noise=sog_noise_temp=0.1_scaling=False_sst=tree_symmetric=False_target=adaptive_temp=0.1 '
'--use_cpp_for_sampling True --method aimle --imle-lambda 0.0 --imle-lambda-update-step 0.001 --imle-noise sog '
'--imle-noise-temperature 0.1 --aimle-target adaptive --imle-samples 1 --hard True --st True'],
seed=[0, 1, 2, 3, 4, 5, 6, 7],
ckp=['../exp_nri/aimle_v3_T20_nosym_best']
)
configurations = list(cartesian_product(hyp_space_aimle_sym_10)) + \
list(cartesian_product(hyp_space_aimle_nosym_10)) + \
list(cartesian_product(hyp_space_aimle_sym_20)) + \
list(cartesian_product(hyp_space_aimle_nosym_20))
path = 'logs/nri/nribest_beaker_v3'
is_rc = False
# Check that we are on the UCLCS cluster first
if os.path.exists('/home/pminervi/'):
is_rc = True
# If the folder that will contain logs does not exist, create it
if not os.path.exists(path):
os.makedirs(path)
command_lines = set()
for cfg in configurations:
logfile = to_logfile(cfg, path)
completed = False
if os.path.isfile(logfile):
with open(logfile, 'r', encoding='utf-8', errors='ignore') as f:
content = f.read()
completed = 'Optimization Finished' in content
if not completed:
command_line = '{} > {} 2>&1'.format(to_cmd(cfg), logfile)
command_lines |= {command_line}
# Sort command lines and remove duplicates
sorted_command_lines = sorted(command_lines)
import random
rng = random.Random(0)
rng.shuffle(sorted_command_lines)
nb_jobs = len(sorted_command_lines)
header = """#!/bin/bash -l
#$ -cwd
#$ -S /bin/bash
#$ -o $HOME/array.out
#$ -e $HOME/array.err
#$ -t 1-{}
#$ -l tmem=12G
#$ -l h_rt=48:00:00
#$ -l gpu=true
conda activate gpu
export LANG="en_US.utf8"
export LANGUAGE="en_US:en"
export CUDA_LAUNCH_BLOCKING=1
cd $HOME/workspace/l2x-aimle
""".format(nb_jobs)
if is_rc:
print(header)
for job_id, command_line in enumerate(sorted_command_lines, 1):
if is_rc:
print(f'test $SGE_TASK_ID -eq {job_id} && sleep 30 && {command_line}')
else:
print(command_line)
if __name__ == '__main__':
logging.basicConfig(level=logging.INFO)
main(sys.argv[1:])
| 7,054 | 38.413408 | 220 | py |
torch-adaptive-imle | torch-adaptive-imle-main/nri/modules.py | # MIT License
# Copyright (c) 2018 Ethan Fetaya, Thomas Kipf
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
class MLP(nn.Module):
"""Two-layer fully-connected ELU net with batch norm."""
def __init__(self, n_in, n_hid, n_out, do_prob=0.):
super(MLP, self).__init__()
self.fc1 = nn.Linear(n_in, n_hid)
self.fc2 = nn.Linear(n_hid, n_out)
self.bn = nn.BatchNorm1d(n_out)
self.dropout_prob = do_prob
self.init_weights()
def init_weights(self):
for m in self.modules():
if isinstance(m, nn.Linear):
nn.init.xavier_normal_(m.weight.data)
m.bias.data.fill_(0.1)
elif isinstance(m, nn.BatchNorm1d):
m.weight.data.fill_(1)
m.bias.data.zero_()
def batch_norm(self, inputs):
x = inputs.view(inputs.size(0) * inputs.size(1), -1)
x = self.bn(x)
return x.view(inputs.size(0), inputs.size(1), -1)
def forward(self, inputs):
# Input shape: [num_sims, num_things, num_features]
x = F.elu(self.fc1(inputs))
x = F.dropout(x, self.dropout_prob, training=self.training)
x = F.elu(self.fc2(x))
return self.batch_norm(x)
class MLPEncoder(nn.Module):
def __init__(self, n_in, n_hid, n_out, do_prob=0., factor=True,
use_nvil=False, num_edges=None, n=None, num_timesteps=None,
num_dims=None):
super(MLPEncoder, self).__init__()
self.factor = factor
self.mlp1 = MLP(n_in, n_hid, n_hid, do_prob)
self.mlp2 = MLP(n_hid * 2, n_hid, n_hid, do_prob)
self.mlp3 = MLP(n_hid, n_hid, n_hid, do_prob)
if self.factor:
self.mlp4 = MLP(n_hid * 3, n_hid, n_hid, do_prob)
print("Using factor graph MLP encoder.")
else:
self.mlp4 = MLP(n_hid * 2, n_hid, n_hid, do_prob)
print("Using MLP encoder.")
self.fc_out = nn.Linear(n_hid, n_out)
self.use_nvil = use_nvil
if use_nvil:
self.baseline = nn.Sequential(
nn.Flatten(),
nn.Linear(num_edges * n_hid, n_hid),
nn.ReLU(),
nn.Linear(n_hid, 1)
)
self.init_weights()
def init_weights(self):
for m in self.modules():
if isinstance(m, nn.Linear):
nn.init.xavier_normal_(m.weight.data)
m.bias.data.fill_(0.1)
def edge2node(self, x, rel_rec, rel_send):
# NOTE: Assumes that we have the same graph across all samples.
incoming = torch.matmul(rel_rec.t(), x)
return incoming / incoming.size(1)
def node2edge(self, x, rel_rec, rel_send):
# NOTE: Assumes that we have the same graph across all samples.
receivers = torch.matmul(rel_rec, x)
senders = torch.matmul(rel_send, x)
edges = torch.cat([senders, receivers], dim=2)
return edges
def forward(self, inputs, rel_rec, rel_send):
# Input shape: [num_sims, num_vertices, num_timesteps, num_dims]
x = inputs.view(inputs.size(0), inputs.size(1), -1)
# New shape: [num_sims, num_vertices, num_timesteps*num_dims]
x = self.mlp1(x) # 2-layer ELU net per node
x = self.node2edge(x, rel_rec, rel_send)
x = self.mlp2(x)
x_skip = x
if self.factor:
x = self.edge2node(x, rel_rec, rel_send)
x = self.mlp3(x)
x = self.node2edge(x, rel_rec, rel_send)
x = torch.cat((x, x_skip), dim=2) # Skip connection
x = self.mlp4(x)
else:
x = self.mlp3(x)
x = torch.cat((x, x_skip), dim=2) # Skip connection
x = self.mlp4(x)
if self.use_nvil:
out = self.fc_out(x)
return out, self.baseline(x).squeeze(1)
else:
return self.fc_out(x), None
class MLPDecoder(nn.Module):
"""MLP decoder module."""
def __init__(self, n_in_node, edge_types, msg_hid, msg_out, n_hid,
do_prob=0., skip_first=False, num_rounds=1):
super(MLPDecoder, self).__init__()
self.msg_fc1 = nn.ModuleList(
[nn.Linear(2 * n_in_node, msg_hid) for _ in range(edge_types)])
self.msg_fc2 = nn.ModuleList(
[nn.Linear(msg_hid, msg_out) for _ in range(edge_types)])
self.msg_out_shape = msg_out
self.skip_first_edge_type = skip_first
self.num_rounds = num_rounds
self.out_fc1 = nn.Linear(n_in_node + msg_out, n_hid)
self.out_fc2 = nn.Linear(n_hid, n_hid)
self.out_fc3 = nn.Linear(n_hid, n_in_node)
print("Using learned interaction net decoder.")
self.dropout_prob = do_prob
def single_step_forward(self, single_timestep_inputs, rel_rec, rel_send,
single_timestep_rel_type):
# single_timestep_inputs has shape
# [batch_size, num_timesteps, num_vertices, num_dims]
# single_timestep_rel_type has shape:
# [batch_size, num_timesteps, num_vertices*(num_vertices-1), num_edge_types]
# Node2edge
receivers = torch.matmul(rel_rec, single_timestep_inputs)
senders = torch.matmul(rel_send, single_timestep_inputs)
pre_msg = torch.cat([senders, receivers], dim=-1)
all_msgs = Variable(torch.zeros(pre_msg.size(0), pre_msg.size(1),
pre_msg.size(2), self.msg_out_shape))
if single_timestep_inputs.is_cuda:
all_msgs = all_msgs.cuda()
if self.skip_first_edge_type:
start_idx = 1
else:
start_idx = 0
# Run separate MLP for every edge type
# NOTE: To exlude one edge type, simply offset range by 1
for i in range(start_idx, len(self.msg_fc2)):
msg = F.relu(self.msg_fc1[i](pre_msg))
msg = F.dropout(msg, p=self.dropout_prob)
msg = F.relu(self.msg_fc2[i](msg))
# this is needed by IMLE if we draw multiple samples
batch_size = msg.shape[0]
batch_size_imle = single_timestep_rel_type.shape[0]
if batch_size_imle > batch_size:
nb_samples = batch_size_imle // batch_size
msg_imle = msg.view(batch_size, 1, -1).repeat(1, nb_samples, 1)
msg_imle = msg_imle.view([batch_size_imle] + list(msg.shape)[1:])
msg = msg_imle
msg = msg * single_timestep_rel_type[:, :, :, i:i + 1]
# this is needed by IMLE if we draw multiple samples
batch_size = all_msgs.shape[0]
batch_size_imle = msg.shape[0]
if batch_size_imle > batch_size:
nb_samples = batch_size_imle // batch_size
all_msgs_imle = all_msgs.view(batch_size, 1, -1).repeat(1, nb_samples, 1)
all_msgs_imle = all_msgs_imle.view([batch_size_imle] + list(all_msgs.shape)[1:])
all_msgs = all_msgs_imle
all_msgs += msg
# Aggregate all msgs to receiver
agg_msgs = all_msgs.transpose(-2, -1).matmul(rel_rec).transpose(-2, -1)
agg_msgs = agg_msgs.contiguous()
# this is needed by IMLE if we draw multiple samples
batch_size = single_timestep_inputs.shape[0]
batch_size_imle = agg_msgs.shape[0]
if batch_size_imle > batch_size:
nb_samples = batch_size_imle // batch_size
single_timestep_inputs_imle = single_timestep_inputs.reshape(batch_size, 1, -1).repeat(1, nb_samples, 1)
single_timestep_inputs_imle = single_timestep_inputs_imle.view([batch_size_imle] + list(single_timestep_inputs.shape)[1:])
single_timestep_inputs = single_timestep_inputs_imle
# Skip connection
aug_inputs = torch.cat([single_timestep_inputs, agg_msgs], dim=-1)
# Output MLP
pred = F.dropout(F.relu(self.out_fc1(aug_inputs)), p=self.dropout_prob)
pred = F.dropout(F.relu(self.out_fc2(pred)), p=self.dropout_prob)
pred = self.out_fc3(pred)
# Predict position/velocity difference
return pred + single_timestep_inputs
def forward(self, inputs, rel_type, rel_rec, rel_send, pred_steps=1):
# NOTE: Assumes that we have the same graph across all samples.
inputs = inputs.transpose(1, 2).contiguous()
sizes = [rel_type.size(0), inputs.size(1), rel_type.size(1),
rel_type.size(2)]
rel_type = rel_type.unsqueeze(1).expand(sizes)
time_steps = inputs.size(1)
assert (pred_steps <= time_steps)
preds = []
# Only take n-th timesteps as starting points (n: pred_steps)
last_pred = inputs[:, 0::pred_steps, :, :]
curr_rel_type = rel_type[:, 0::pred_steps, :, :]
# NOTE: Assumes rel_type is constant (i.e. same across all time steps).
# Run n prediction steps
for step in range(0, pred_steps):
for _ in range(self.num_rounds):
last_pred = self.single_step_forward(last_pred, rel_rec, rel_send,
curr_rel_type)
preds.append(last_pred)
sizes = [preds[0].size(0), preds[0].size(1) * pred_steps,
preds[0].size(2), preds[0].size(3)]
output = Variable(torch.zeros(sizes))
if inputs.is_cuda:
output = output.cuda()
# Re-assemble correct timeline
for i in range(len(preds)):
output[:, i::pred_steps, :, :] = preds[i]
pred_all = output[:, :(inputs.size(1) - 1), :, :]
return pred_all.transpose(1, 2).contiguous()
| 10,790 | 38.24 | 134 | py |
torch-adaptive-imle | torch-adaptive-imle-main/nri/utils.py | import time
import numpy as np
import torch
from torch import Tensor
from torch.utils.data.dataset import TensorDataset
from torch.utils.data import DataLoader
from nri.core.spanning_tree import sample_tree_from_logits
from nri.core.topk import sample_topk_from_logits
torch.set_printoptions(precision=32)
EPS = torch.finfo(torch.float32).tiny
def get_experiments_folder(args):
folder = args.suffix.strip("_")
# SST-related parameters.
if args.sst == "tree":
folder += f"_tree_{args.relaxation}"
folder += f"_mr{args.max_range}" if args.max_range > -np.inf else ""
elif args.sst == "topk":
folder += f"_topk_{args.relaxation}"
else: # args.sst == "indep"
folder += f"_indep"
# Whether or not kl is computed wrt U (gumbels).
folder += "_gkl" if args.use_gumbels_for_kl else ""
# For when REINFORCE or NVIL is used.
if args.use_reinforce:
folder += f"_reinforce_{args.reinforce_baseline}"
if args.use_nvil:
folder += "_nvil"
folder += f"_nedgetypes{args.edge_types}"
folder += f"_edgesymm" if args.symmeterize_logits else ""
folder += f"_pred{args.prediction_steps}"
folder += f"_r{args.num_rounds}"
if args.add_timestamp:
timestr = time.strftime("%Y%m%d")
folder += f"_{timestr}"
return folder
def get_experiment_name(args):
name = (f"lr{args.lr}_temp{args.temp}_encwd{args.enc_weight_decay}"
f"_decwd{args.dec_weight_decay}")
if args.sst == "topk":
name += f"_eps{args.eps_for_finitediff}"
if (args.use_reinforce or args.use_nvil) and args.ema_for_loss > 0.0:
name += f"_ema{args.ema_for_loss}"
name += f"_{args.seed}"
return name
def load_data(batch_size, eval_batch_size, suffix, normalize=True):
data_train = np.load(f"data/data_train{suffix}.npy")
edges_train = np.load(f"data/edges_train{suffix}.npy")
data_valid = np.load(f"data/data_valid{suffix}.npy")
edges_valid = np.load(f"data/edges_valid{suffix}.npy")
data_test = np.load(f"data/data_test{suffix}.npy")
edges_test = np.load(f"data/edges_test{suffix}.npy")
# [num_samples, num_timesteps, num_dims, num_vertices]
num_vertices = data_train.shape[3]
data_max = data_train.max()
data_min = data_train.min()
# Normalize to [-1, 1]
if normalize:
data_train = (data_train - data_min) * 2 / (data_max - data_min) - 1
data_valid = (data_valid - data_min) * 2 / (data_max - data_min) - 1
data_test = (data_test - data_min) * 2 / (data_max - data_min) - 1
# Reshape to: [num_sims, num_vertices, num_timesteps, num_dims]
feat_train = np.transpose(data_train, [0, 3, 1, 2])
# Transpose edges to be consistent with the output of the encoder,
# which is corresponds to a flattened adjacency matrix that is transposed
# and has its diagonal removed. This is not necessary when the input
# data is symmetric, which is the case for the graph layout data,
# but is still added for consistency.
edges_train = np.transpose(edges_train, [0, 2, 1])
edges_train = np.reshape(edges_train, [-1, num_vertices ** 2])
edges_train = np.array((edges_train + 1) / 2, dtype=np.int64)
feat_valid = np.transpose(data_valid, [0, 3, 1, 2])
edges_valid = np.transpose(edges_valid, [0, 2, 1])
edges_valid = np.reshape(edges_valid, [-1, num_vertices ** 2])
edges_valid = np.array((edges_valid + 1) / 2, dtype=np.int64)
feat_test = np.transpose(data_test, [0, 3, 1, 2])
edges_test = np.transpose(edges_test, [0, 2, 1])
edges_test = np.reshape(edges_test, [-1, num_vertices ** 2])
edges_test = np.array((edges_test + 1) / 2, dtype=np.int64)
feat_train = torch.FloatTensor(feat_train)
edges_train = torch.LongTensor(edges_train)
feat_valid = torch.FloatTensor(feat_valid)
edges_valid = torch.LongTensor(edges_valid)
feat_test = torch.FloatTensor(feat_test)
edges_test = torch.LongTensor(edges_test)
# Exclude self edges
off_diag_idx = np.ravel_multi_index(
np.where(np.ones((num_vertices, num_vertices)) - np.eye(num_vertices)),
[num_vertices, num_vertices])
edges_train = edges_train[:, off_diag_idx]
edges_valid = edges_valid[:, off_diag_idx]
edges_test = edges_test[:, off_diag_idx]
train_data = TensorDataset(feat_train, edges_train)
valid_data = TensorDataset(feat_valid, edges_valid)
test_data = TensorDataset(feat_test, edges_test)
train_data_loader = DataLoader(train_data, batch_size=batch_size)
valid_data_loader = DataLoader(valid_data, batch_size=eval_batch_size)
test_data_loader = DataLoader(test_data, batch_size=eval_batch_size)
return (train_data_loader, valid_data_loader, test_data_loader,
data_train.shape[0], data_valid.shape[0], data_test.shape[0])
def encode_onehot(labels):
classes = set(labels)
classes_dict = {c: np.identity(len(classes))[i, :] for i, c in enumerate(classes)}
labels_onehot = np.array(list(map(classes_dict.get, labels)), dtype=np.int32)
return labels_onehot
def kl_categorical_uniform(preds, num_vertices, num_edge_types, add_const=False,
eps=1e-16):
kl_div = preds * (torch.log(preds + eps) + torch.log(torch.tensor(float(num_edge_types))))
if add_const:
const = np.log(num_edge_types)
kl_div += const
return kl_div.sum((1, 2)) / num_vertices
def kl_gumbel(logits, num_vertices):
"""Computes the analytical kl(q(z|x)||p(z)) = u + exp(-u) - 1.
q(z|x) is gumbel distributed with location (u) given by logits.
p(z) is gumbel distributed with location zero.
"""
kl_div = logits + torch.exp(-logits) - 1.0
return kl_div.sum((1, 2)) / num_vertices
def nll_gaussian(preds, target, variance, add_const=False):
# print('Predictions', preds.shape, 'Target', target.shape)
# this is needed by IMLE if we draw multiple samples
batch_size = target.shape[0]
batch_size_imle = preds.shape[0]
nb_samples = batch_size_imle // batch_size
if nb_samples > 1:
target_imle = target.reshape(batch_size, 1, -1).repeat(1, nb_samples, 1)
target_imle = target_imle.view([batch_size_imle] + list(target.shape)[1:])
target = target_imle
neg_log_p = ((preds - target) ** 2 / (2 * variance))
if add_const:
const = 0.5 * np.log(2 * np.pi * variance)
neg_log_p += const
# print('Scaling factor', target.size(1))
res = neg_log_p.sum((1, 2, 3)) / target.size(1)
# print('Return shape', res.shape)
return res
def sample_indep_edges(logits, is_edgesymmetric=False, tau=1.0, hard=False,
hard_with_grad=False):
"""Sample independent edges given logits.
Args:
logits: Logits of shape (batch_size, n * (n - 1), edge_types).
They correspond to a flattened and transposed adjacency matrix
with the diagonals removed.
We assume the logits are edge-symmetric.
is_edgesymmetric: Whether or not e_ij == e_ji. If True, then we must
only sample one gumbel per undirected edge.
tau: Float representing temperature.
hard: Whether or not to sample hard edges.
hard_with_grad: Whether or not to allow sample hard, but have gradients
for backprop.
Returns:
Sampled edges with the same shape as logits, and
sampled edge weights of same shape as logits.
"""
if is_edgesymmetric:
# If we want to have undirected edges, we must sample the same gumbel
# for both directed edges for the same nodes pair
# (i.e. gumbel_ij == gumbel_ji). Therefore, we need to separate only
# the upper triangle of the adjacency matrix.
edge_types = logits.size(2)
# n * (n - 1) = len(logits), where n is the number of vertices.
n = int(0.5 * (1 + np.sqrt(4 * logits.size(1) + 1)))
# Reshape to adjacency matrix (with the diagonals removed).
reshaped_logits = logits.view(-1, n, n - 1, edge_types)
reshaped_logits = reshaped_logits.transpose(1, 2) # (bs, n-1, n, edge_types)
vertices = torch.triu_indices(n-1, n, offset=1)
edge_logits = reshaped_logits[:, vertices[0], vertices[1], :]
else:
edge_logits = logits
# print('XXX', logits.shape, edge_logits.shape)
# print(logits[0, ...])
# Clamp uniforms for numerical stability.
uniforms = torch.empty_like(edge_logits).float().uniform_().clamp_(EPS, 1 - EPS)
gumbels = uniforms.log().neg().log().neg()
gumbels = gumbels.cuda() if logits.is_cuda else gumbels
edge_weights = gumbels + edge_logits
hard = True if hard_with_grad else hard
if hard:
top1_indices = torch.argmax(edge_weights, dim=-1, keepdim=True)
X = torch.zeros_like(edge_weights).scatter(-1, top1_indices, 1.0)
hard_X = X
if not hard or hard_with_grad:
X = torch.nn.functional.softmax(edge_weights / tau, dim=-1)
if hard_with_grad:
X = (hard_X - X).detach() + X
if is_edgesymmetric:
samples = torch.zeros_like(reshaped_logits)
samples[:, vertices[0], vertices[1], :] = X
samples[:, vertices[1] - 1, vertices[0], :] = X
# Return the flattened sample in the same format as the input logits.
samples = samples.transpose(1, 2).contiguous().view(*logits.shape)
# Make sampled edge weights into adj matrix format.
edge_weights_reshaped = torch.zeros_like(reshaped_logits)
edge_weights_reshaped[:, vertices[0], vertices[1]] = edge_weights
edge_weights_reshaped[:, vertices[1] - 1, vertices[0]] = edge_weights
edge_weights = edge_weights_reshaped.transpose(1, 2).contiguous().view(*logits.shape)
return samples, edge_weights
else:
return X, edge_weights
def sampling_edge_metrics(logits, target, sst, n, num_samples=1,
is_edgesymmetric=False, use_cpp=False):
"""Compute edge metrics by sampling num_samples many hard samples for each
element in a batch of logits.
"""
tiled_logits = logits.repeat(num_samples, 1, 1)
if sst == "indep":
samples, _ = sample_indep_edges(tiled_logits, is_edgesymmetric, hard=True)
elif sst == "topk":
samples, _ = sample_topk_from_logits(tiled_logits, n - 1, hard=True)
elif sst == "tree":
samples, _ = sample_tree_from_logits(tiled_logits, hard=True, use_cpp=use_cpp)
else:
raise ValueError(f"Stochastic Softmax Trick type {sst} is not valid!")
edge_types = logits.size(2)
# If there is only one edge type, we don't know whether this should
# represent 'on' or 'off' edges. Therefore, we add another another
# edge type. We compute edge metrics on both versions of the graph
# and pick whichever version that gives the best precision.
if edge_types == 1:
samples = torch.cat((1.0 - samples, samples), dim=-1)
# Samples is shape (num_samples, batch size, )
samples = samples.view(num_samples, logits.size(0), logits.size(1), 2)
target = target.unsqueeze(0).unsqueeze(-1).repeat((1, 1, 1, 2))
one = torch.tensor(1.0).cuda() if samples.is_cuda else torch.tensor(1.0)
zero = torch.tensor(0.0).cuda() if samples.is_cuda else torch.tensor(0.0)
# Compute true/false positives/negatives for metric calculations.
tp = torch.where(samples * target == 1.0, one, zero).sum(-2)
tn = torch.where(samples + target == 0.0, one, zero).sum(-2)
fp = torch.where(samples - target == 1.0, one, zero).sum(-2)
fn = torch.where(samples - target == -1.0, one, zero).sum(-2)
# Calculate accuracy.
accs = torch.mean((tp + tn) / (tp + tn + fp + fn), axis=(0, 1)).cpu().detach()
# Calculate precision.
precisions = torch.mean(tp / (tp + fp), axis=(0, 1)).cpu().detach()
# Calculate recall.
recalls = torch.mean(tp / (tp + fn), axis=(0, 1)).cpu().detach()
return accs.numpy(), precisions.numpy(), recalls.numpy()
def maybe_make_logits_symmetric(logits, symmeterize_logits):
"""Make logits symmetric wrt edges; logits_ij = logits_ji.
This is done by taking the average of the edge representations for both
directions.
Args:
logits: Shape (batch_size, n * (n - 1), edge_types).
symmeterize_logits: Whether or not to symmeterize logits.
Returns:
Symmeterized logits of same shape as logits.
"""
if symmeterize_logits:
n = int(0.5 * (1 + np.sqrt(4 * logits.size(1) + 1)))
# Input logits is a flatted and transposed adjacency matrix with the
# diagonals removed:
# logits = [(1, 0), (2, 0), ..., (n-1, 0), ..., (1, n-1), ..., (n-2, n-1)]
# (see rel_rec and rel_send vectors in train.py).
# Reshape to adjacency matrix (with the diagonals removed).
reshaped_logits = logits.view(-1, n, n-1, logits.size(-1))
reshaped_logits = reshaped_logits.permute(0, 3, 2, 1) # (bs, -1, n-1, n)
# Transform the logits such that it is symmetric wrt edge direction
# i.e. logit_ij = logit_ji.
vertices = torch.triu_indices(n - 1, n, offset=1)
upper_tri = reshaped_logits[:, :, vertices[0], vertices[1]]
lower_tri = reshaped_logits[:, :, vertices[1] - 1, vertices[0]]
new_logits = (upper_tri + lower_tri) / 2.0
symmetric_logits = torch.zeros_like(reshaped_logits)
symmetric_logits[:, :, vertices[0], vertices[1]] = new_logits
symmetric_logits[:, :, vertices[1] - 1, vertices[0]] = new_logits
# Bring the symmetric adjacency matrix back to format of logits.
symmetric_logits = symmetric_logits.permute(0, 3, 2, 1).flatten(1, 2)
return symmetric_logits
else:
return logits
def map_estimator(logits: Tensor, use_cpp_for_sampling: bool = True):
n = int(0.5 * (1 + np.sqrt(4 * logits.size(1) + 1)))
# logits is [B, 90, 1]
# reshaped_logits is [B, 10, 9]
reshaped_logits = logits.view(-1, n, n - 1)
# reshaped_logits is [B, 9, 10]
reshaped_logits = reshaped_logits.transpose(1, 2) # (bs, n-1, n)
vertices = torch.triu_indices(n - 1, n, offset=1)
edge_logits = reshaped_logits[:, vertices[0], vertices[1]]
edge_weights_ = edge_logits
tiled_vertices = vertices.transpose(0, 1).repeat((edge_weights_.size(0), 1, 1)).float()
tiled_vertices = tiled_vertices.cuda() if logits.is_cuda else tiled_vertices
weights_and_edges = torch.cat([edge_weights_.unsqueeze(-1), tiled_vertices], axis=-1)
if use_cpp_for_sampling:
from nri.core.kruskals.kruskals import kruskals_cpp_pytorch
ss_edges = kruskals_cpp_pytorch(weights_and_edges.detach().cpu(), n)
ss_edges = ss_edges.to("cuda") if logits.is_cuda else ss_edges
else:
from nri.core.kruskals.kruskals import kruskals_pytorch_batched
ss_edges = kruskals_pytorch_batched(weights_and_edges, n)
# [B, 90, 1]
ss_edges = ss_edges.transpose(1, 2).contiguous().view(-1, n * (n - 1), 1)
return ss_edges
| 15,055 | 40.136612 | 94 | py |
torch-adaptive-imle | torch-adaptive-imle-main/nri/core/topk.py | import torch
from torch.autograd import Function
import numpy as np
import numpy.random as npr
import scipy.special as spec
EPS = torch.finfo(torch.float32).tiny
INF = np.finfo(np.float32).max
def softtopk_forward_np(logits, k):
batchsize, n = logits.shape
messages = -INF * np.ones((batchsize, n, k + 1))
messages[:, 0, 0] = 0
messages[:, 0, 1] = logits[:, 0]
for i in range(1, n):
for j in range(k + 1):
logp_dont_use = messages[:, i - 1, j]
logp_use = (
messages[:, i - 1, j - 1] + logits[:, i] if j > 0 else -INF)
message = np.logaddexp(logp_dont_use, logp_use)
messages[:, i, j] = message
return messages
def softtopk_backward_np(logits, k):
batchsize, n = logits.shape
messages = -INF * np.ones((batchsize, n, k + 1))
messages[:, n - 1, k] = 0
for i in range(n - 2, -1, -1):
for j in range(k + 1):
logp_dont_use = messages[:, i + 1, j]
logp_use = (
messages[:, i + 1, j + 1] + logits[:, i + 1] if j < k else -INF)
message = np.logaddexp(logp_dont_use, logp_use)
messages[:, i, j] = message
return messages
def softtopk_np(logits, k):
batchsize = logits.shape[0]
f = softtopk_forward_np(logits, k)
b = softtopk_backward_np(logits, k)
initial_f = -INF * np.ones((batchsize, 1, k + 1))
initial_f[:, :, 0] = 0
ff = np.concatenate([initial_f, f[:, :-1, :]], axis=1)
lse0 = spec.logsumexp(ff + b, axis=2)
lse1 = spec.logsumexp(ff[:, :, :-1] + b[:, :, 1:], axis=2) + logits
return np.exp(lse1 - np.logaddexp(lse0, lse1))
class SoftTopK(torch.autograd.Function):
@staticmethod
def forward(ctx, logits, k, eps):
# ctx is a context object that can be used to stash information
# for backward computation.
ctx.save_for_backward(logits)
ctx.k = k
ctx.eps = eps
dtype = logits.dtype
device = logits.device
mu_np = softtopk_np(logits.cpu().detach().numpy(), k)
mu = torch.from_numpy(mu_np).type(dtype).to(device)
return mu
@staticmethod
def backward(ctx, grad_output):
# We return as many input gradients as there were arguments.
# Gradients of non-Tensor arguments to forward must be None.
r"""http://www.cs.toronto.edu/~kswersky/wp-content/uploads/carbm.pdf"""
logits, = ctx.saved_tensors
k = ctx.k
eps= ctx.eps
dtype = grad_output.dtype
device = grad_output.device
logits_np = logits.cpu().detach().numpy()
grad_output_np = grad_output.cpu().detach().numpy()
n1 = softtopk_np(logits_np + eps * grad_output_np, k)
n2 = softtopk_np(logits_np - eps * grad_output_np, k)
grad_np = (n1 - n2) / (2 * eps)
grad = torch.from_numpy(grad_np).type(dtype).to(device)
return grad, None, None
def sample_topk_from_logits(logits, k, tau=1.0, hard=False,
hard_with_grad=False, edge_types=1,
relaxation="exp_family_entropy",
eps=1e-2):
"""Does k-subset selection given logits.
Args:
logits: Logits of shape (batch size, n * (n - 1), 1).
They correspond to a flattened and transposed adjacency matrix
with the diagonals removed.
We assume the logits are edge-symmetric.
k: Subset selection size.
tau: Float representing temperature.
hard: Whether or not to sample hard edges.
hard_with_grad: Whether or not to allow sample hard, but have gradients
for backprop.
edge_tpes: Number of edge types for the output. Must be 1 or 2.
relaxation: Relaxation type.
Returns:
Sampled edges with the same shape as logits, and
sampled edge weights of same shape as logits.
"""
# n * (n - 1) = len(logits), where n is the number of vertices.
n = int(0.5 * (1 + np.sqrt(4 * logits.size(1) + 1)))
# First check that there is only one edge type.
assert logits.size(2) == 1
# Reshape to adjacency matrix (with the diagonals removed).
reshaped_logits = logits.view(-1, n, n - 1)
reshaped_logits = reshaped_logits.transpose(1, 2) # (bs, n-1, n)
vertices = torch.triu_indices(n-1, n, offset=1)
edge_logits = reshaped_logits[:, vertices[0], vertices[1]]
uniforms = torch.empty_like(edge_logits).float().uniform_().clamp_(EPS, 1 - EPS)
gumbels = uniforms.log().neg().log().neg()
gumbels = gumbels.cuda() if logits.is_cuda else gumbels
edge_weights = gumbels + edge_logits
hard = True if hard_with_grad else hard
if hard:
_, topk_indices = torch.topk(edge_weights, k, dim=-1)
X = torch.zeros_like(edge_logits).scatter(-1, topk_indices, 1.0)
hard_X = X
if not hard or hard_with_grad:
weights = edge_weights / tau
if relaxation == "exp_family_entropy":
X = SoftTopK.apply(weights, k, eps)
elif relaxation == "binary_entropy":
# Limited Multi-Label Projection Layer (Amos et al.).
raise ValueError("Binary entropy for topk not implemented.")
else:
raise ValueError("Invalid relaxation for topk.")
if hard_with_grad:
X = (hard_X - X).detach() + X
samples = torch.zeros_like(reshaped_logits)
samples[:, vertices[0], vertices[1]] = X
samples[:, vertices[1] - 1, vertices[0]] = X
if edge_types == 2:
samples = torch.stack((1.0 - samples, samples), dim=-1)
else:
samples = samples.unsqueeze(-1)
# Return the flattened sample in the same format as the input logits.
samples = samples.transpose(1, 2).contiguous().view(-1, n * (n - 1), edge_types)
# Make sampled edge weights into adj matrix format.
edge_weights_reshaped = torch.zeros_like(reshaped_logits)
edge_weights_reshaped[:, vertices[0], vertices[1]] = edge_weights
edge_weights_reshaped[:, vertices[1] - 1, vertices[0]] = edge_weights
edge_weights = edge_weights_reshaped.transpose(1, 2).contiguous().view(logits.shape)
return samples, edge_weights
| 6,197 | 37.02454 | 88 | py |
torch-adaptive-imle | torch-adaptive-imle-main/nri/core/spanning_tree.py | import time
from itertools import chain, combinations, permutations
import numpy as np
import torch
torch.set_printoptions(precision=32)
import cvxpy as cp
from cvxpylayers.torch import CvxpyLayer
from nri.core.kruskals.kruskals import get_tree
from nri.core.kruskals.kruskals import kruskals_pytorch_batched
EPS = torch.finfo(torch.float32).tiny
def powerset(iterable):
"powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)"
s = list(iterable)
return chain.from_iterable(combinations(s, r) for r in range(len(s) + 1))
def get_edges_from_vertices(vertices, num_vertices):
idx = 0
edges = []
for i in range(num_vertices):
for j in range(i + 1, num_vertices):
if i in vertices and j in vertices:
edges.append(idx)
idx = idx + 1
return edges
def submatrix_index(n, i):
bs = i.size(0)
I = torch.ones((bs, n, n), dtype=bool)
I[torch.arange(bs), i, :] = False
I[torch.arange(bs), :, i] = False
return I
def get_spanning_tree_marginals(logits, n):
bs = logits.size(0)
(i, j) = torch.triu_indices(n, n, offset=1)
c = torch.max(logits, axis=-1, keepdims=True)[0]
k = torch.argmax(logits, axis=-1)
removei = i[k]
weights = torch.exp(logits - c)
W = torch.zeros(weights.size(0), n, n)
W = W.cuda() if logits.is_cuda else W
W[:, i, j] = weights
W[:, j, i] = weights
L = torch.diag_embed(W.sum(axis=-1)) - W
subL = L[submatrix_index(n, removei)].view(bs, n - 1, n - 1)
logzs = torch.slogdet(subL)[1]
logzs = torch.sum(logzs + (n - 1) * c.flatten())
sample = torch.autograd.grad(logzs, logits, create_graph=True)[0]
return sample
def clip_range(x, max_range=np.inf):
m = torch.max(x, axis=-1, keepdim=True)[0]
return torch.max(x, -1.0 * torch.tensor(max_range) * torch.ones_like(x) + m)
def sample_tree_from_logits(logits, tau=1.0, hard=False, hard_with_grad=False,
edge_types=1, relaxation="exp_family_entropy",
max_range=np.inf, use_cpp=False):
"""Samples a maximum spanning tree given logits.
Args:
logits: Logits of shape (batch_size, n * (n - 1), 1).
They correspond to a flattened and transposed adjacency matrix
with the diagonals removed.
We assume the logits are edge-symmetric.
tau: Float representing temperature.
hard: Whether or not to sample hard edges.
hard_with_grad: Whether or not to allow sample hard, but have gradients
for backprop.
edge_types: Number of edge types for the output. Must be 1 or 2.
relaxation: Relaxation type.
max_range: Maxiumum range between maximum edge weight and any other
edge weights. Used for relaxation == "exp_family_entropy" only.
use_cpp: Whether or not to use the C++ implementation of kruskal's
algorithm for hard sampling.
Returns:
Sampled edges with the same shape as logits, and
sampled edge weights of same shape as logits.
"""
# n * (n - 1) = len(logits), where n is the number of vertices.
n = int(0.5 * (1 + np.sqrt(4 * logits.size(1) + 1)))
# print('XXX', logits.shape, logits.shape, edge_types)
# First check that there is only one edge type.
assert logits.size(2) == 1
# Reshape to adjacency matrix (with the diagonals removed).
reshaped_logits = logits.view(-1, n, n - 1)
reshaped_logits = reshaped_logits.transpose(1, 2) # (bs, n-1, n)
vertices = torch.triu_indices(n-1, n, offset=1)
edge_logits = reshaped_logits[:, vertices[0], vertices[1]]
uniforms = torch.empty_like(edge_logits).float().uniform_().clamp_(EPS, 1 - EPS)
gumbels = uniforms.log().neg().log().neg()
gumbels = gumbels.cuda() if logits.is_cuda else gumbels
edge_weights = gumbels + edge_logits
hard = True if hard_with_grad else hard
if hard:
tiled_vertices = vertices.transpose(0, 1).repeat((edge_weights.size(0), 1, 1)).float()
tiled_vertices = tiled_vertices.cuda() if logits.is_cuda else tiled_vertices
weights_and_edges = torch.cat([edge_weights.unsqueeze(-1), tiled_vertices], axis=-1)
if use_cpp:
from nri.core.kruskals.kruskals import kruskals_cpp_pytorch
samples = kruskals_cpp_pytorch(weights_and_edges.detach().cpu(), n)
samples = samples.to("cuda") if logits.is_cuda else samples
else:
samples = kruskals_pytorch_batched(weights_and_edges, n)
if edge_types == 2:
null_edges = 1.0 - samples
samples = torch.stack((null_edges, samples), dim=-1)
else:
samples = samples.unsqueeze(-1)
hard_samples = samples
if not hard or hard_with_grad:
if relaxation == 'exp_family_entropy':
weights = edge_weights / tau
weights = clip_range(weights, max_range)
X = get_spanning_tree_marginals(weights, n)
elif relaxation == "binary_entropy": # Soft sample using CVXPY.
# Very slow!
# Define the DPP problem.
x = cp.Variable(edge_weights.size(1))
y = cp.Parameter(edge_weights.size(1))
obj = -x @ y - (cp.sum(cp.entr(x)) + cp.sum(cp.entr(1.0 - x)))
subsets_of_vertices = [torch.IntTensor(l) for l in powerset(torch.arange(n))
if (len(l) >= 2 and len(l) < n)]
edges_list = [get_edges_from_vertices(s, n) for s in subsets_of_vertices]
cons = [cp.sum(x) == (n - 1.0), x >= 0.0]
for i in range(len(edges_list)):
cons.append(cp.sum(x[edges_list[i]]) <= (len(subsets_of_vertices[i]) - 1.0))
prob = cp.Problem(cp.Minimize(obj), cons)
layer = CvxpyLayer(prob, parameters=[y], variables=[x])
X, = layer(edge_weights / tau)
else:
raise ValueError("Invalid relaxation for spanning tree.")
samples = torch.zeros_like(reshaped_logits)
samples[:, vertices[0], vertices[1]] = X
samples[:, vertices[1] - 1, vertices[0]] = X
if edge_types == 2:
samples = torch.stack((1.0 - samples, samples), dim=-1)
else:
samples = samples.unsqueeze(-1)
if hard_with_grad:
samples = (hard_samples - samples).detach() + samples
# Return the flattened sample in the same format as the input logits.
samples = samples.transpose(1, 2).contiguous().view(-1, n * (n - 1), edge_types)
# Make sampled edge weights into adj matrix format.
edge_weights_reshaped = torch.zeros_like(reshaped_logits)
edge_weights_reshaped[:, vertices[0], vertices[1]] = edge_weights
edge_weights_reshaped[:, vertices[1] - 1, vertices[0]] = edge_weights
edge_weights = edge_weights_reshaped.transpose(1, 2).contiguous().view(logits.shape)
return samples, edge_weights
def enumerate_spanning_trees(weights_and_edges, n):
"""
Args:
weights_and_edges: Shape (n * (n - 2), 3).
n: Number of vertices.
"""
probs = {}
for edgeperm in permutations(weights_and_edges):
edgeperm = torch.stack(edgeperm)
tree = get_tree(edgeperm[:, 1:].int(), n)
weights = edgeperm[:, 0]
logprob = 0
for i in range(len(weights)):
logprob += weights[i] - torch.logsumexp(weights[i:], dim=0)
tree_str = "".join([str(x) for x in tree.flatten().int().numpy()])
if tree_str in probs:
probs[tree_str] = probs[tree_str] + torch.exp(logprob)
else:
probs[tree_str] = torch.exp(logprob)
return probs
def compute_probs_for_tree(logits, use_gumbels=True):
if use_gumbels:
return logits
# n * (n - 1) = len(logits), where n is the number of vertices.
n = int(0.5 * (1 + np.sqrt(4 * logits.size(1) + 1)))
# Reshape to adjacency matrix (with the diagonals removed).
reshaped_logits = logits.view(-1, n, n - 1)
reshaped_logits = reshaped_logits.transpose(1, 2) # (bs, n-1, n)
# Get the edge logits (upper triangle).
vertices = torch.triu_indices(n-1, n, offset=1)
edge_logits = reshaped_logits[:, vertices[0], vertices[1]]
probs = []
for weights in edge_logits:
weights_and_edges = torch.Tensor(
[list(e) for e in zip(weights, vertices[0], vertices[1])])
p_dict = enumerate_spanning_trees(weights_and_edges, n)
p = torch.tensor(list(p_dict.values()))
probs.append(p)
probs = torch.stack(probs)
return probs
if __name__ == "__main__":
##################### Testing compute_probs_for_tree #####################
bs = 1
n = 4
logits = torch.rand((bs, n * (n-1)))
prob = compute_probs_for_tree(logits, use_gumbels=False)
np.testing.assert_almost_equal(prob.sum(axis=-1).numpy(), np.ones((bs,)))
| 8,903 | 37.051282 | 94 | py |
torch-adaptive-imle | torch-adaptive-imle-main/nri/core/edmonds/time_edmonds.py | import argparse
import time
import torch
from edmonds import edmonds_python, edmonds_cpp_pytorch
parser = argparse.ArgumentParser()
parser.add_argument("--n", type=int, default=4, help="Number of nodes.")
parser.add_argument("--batch_size", type=int, default=128, help="Batch size.")
parser.add_argument("--num_steps", type=int, default=1,
help="Number of times to evaluate.")
args = parser.parse_args()
adjs = torch.randn(args.batch_size, args.n, args.n)
# Test nx version.
t = 0
for _ in range(args.num_steps):
start = time.time()
res_nx = edmonds_python(adjs.numpy(), args.n)
t += time.time() - start
print(f"Nx version took: {t}; avg: {t / args.num_steps}")
# C++ (cpu) version.
t = 0
for _ in range(args.num_steps):
start = time.time()
res_cpp_cpu = edmonds_cpp_pytorch(adjs, args.n)
t += time.time() - start
print(f"C++ (cpu) version took: {t}; avg: {t / args.num_steps}")
# C++ (gpu) version.
t = 0
for _ in range(args.num_steps):
start = time.time()
res_cpp_gpu = edmonds_cpp_pytorch(adjs.to("cuda"), args.n)
torch.cuda.synchronize()
t += time.time() - start
print(f"C++ (gpu) version took: {t}; avg: {t / args.num_steps}") | 1,199 | 28.268293 | 78 | py |
torch-adaptive-imle | torch-adaptive-imle-main/nri/core/edmonds/edmonds.py | from functools import partial
import networkx as nx
import numpy as np
import torch
import edmonds_cpp
def edmonds_python(adjs, n):
"""
Gets the maximum spanning arborescence given weights of edges.
We assume the root is node (idx) 0.
Args:
adjs: shape (batch_size, n, n), where
adjs[.][i][j] is the weight for edge j -> i.
n: number of vertices.
Returns:
heads. Size (batch_size, n). heads[0] = 0 always.
"""
# Convert roots and weights_and_edges to numpy arrays on the cpu.
if torch.is_tensor(adjs):
adjs = adjs.detach().to("cpu").numpy()
# Loop over batch dimension to get the maximum spanning arborescence for
# each graph.
batch_size = adjs.shape[0]
heads = np.zeros((batch_size, n))
for sample_idx in range(batch_size):
# We transpose adj because networkx accepts adjacency matrix
# where adj[i][j] corresponds to edge i -> j.
np.fill_diagonal(adjs[sample_idx], 0.0)
# We multiply by -1.0 since networkx obtains the
# minimum spanning arborescence. We want the maximum.
G = nx.from_numpy_matrix(-1.0 * adjs[sample_idx].T, create_using=nx.DiGraph())
Gcopy = G.copy()
# Remove all incoming edges for the root such that
# the given "root" is forced to be selected as the root.
Gcopy.remove_edges_from(G.in_edges(nbunch=[0]))
msa = nx.minimum_spanning_arborescence(Gcopy)
# Convert msa nx graph to heads list.
for i, j in msa.edges:
i, j = int(i), int(j)
heads[sample_idx][j] = i
return heads
def edmonds_cpp_pytorch(adjs, n):
"""
Gets the maximum spanning arborescence given weights of edges.
We assume the root is node (idx) 0.
Args:
adjs: shape (batch_size, n, n), where
adjs[.][i][j] is the weight for edge j -> i.
n: number of vertices.
Returns:
heads: Size (batch_size, n).
heads[i] = parent node of i; heads[0] = 0 always.
"""
heads = edmonds_cpp.get_maximum_spanning_arborescence(adjs, n)
return heads
if __name__ == "__main__":
n = 10
bs = 1000
np.random.seed(42)
adjs = np.random.rand(bs, n, n)
res_nx = edmonds_python(adjs, n)
res_cpp = edmonds_cpp_pytorch(torch.tensor(adjs), n).numpy()
np.testing.assert_almost_equal(res_nx, res_cpp)
| 2,430 | 30.571429 | 86 | py |
torch-adaptive-imle | torch-adaptive-imle-main/nri/core/edmonds/setup_edmonds.py | from setuptools import setup, Extension
from torch.utils import cpp_extension
setup(name='edmonds_cpp',
ext_modules=[cpp_extension.CppExtension('edmonds_cpp', ['chuliu_edmonds.cpp'])],
cmdclass={'build_ext': cpp_extension.BuildExtension}) | 251 | 41 | 86 | py |
torch-adaptive-imle | torch-adaptive-imle-main/nri/core/kruskals/time_kruskals.py | import argparse
import time
import torch
from kruskals import kruskals_pytorch, kruskals_pytorch_batched
from kruskals import kruskals_cpp_pytorch, kruskals_cpp_pytorch2
parser = argparse.ArgumentParser()
parser.add_argument("--n", type=int, default=30, help="Number of nodes.")
parser.add_argument("--batch_size", type=int, default=10, help="Batch size.")
parser.add_argument("--num_steps", type=int, default=1,
help="Number of times to evaluate.")
args = parser.parse_args()
num_edges = int(args.n * (args.n - 1) / 2)
weights = torch.randn(args.batch_size, num_edges)
vertices = torch.triu_indices(args.n - 1, args.n, offset=1)
tiled_vertices = vertices.transpose(0, 1).repeat((weights.size(0), 1, 1)).float()
weights_and_edges = torch.cat([weights.unsqueeze(-1), tiled_vertices], axis=-1)
# Test pytorch (batched, gpu).
t = 0
weights_and_edges = weights_and_edges.to("cuda")
for _ in range(args.num_steps):
start = time.time()
res_pytorch = kruskals_pytorch_batched(weights_and_edges, args.n)
torch.cuda.synchronize()
t += time.time() - start
print(f"Pytorch (batched, gpu): {t}; avg: {t / args.num_steps}")
# Test cpp (pytorch, cpu).
t = 0
weights_and_edges = weights_and_edges.to("cpu")
for _ in range(args.num_steps):
start = time.time()
res_pytorch = kruskals_cpp_pytorch(weights_and_edges, args.n)
t += time.time() - start
print(f"C++ (pytorch, cpu): {t}; avg: {t / args.num_steps}")
# Test cpp (pytorch, gpu).
t = 0
weights_and_edges = weights_and_edges.to("cuda")
for _ in range(args.num_steps):
start = time.time()
res_pytorch = kruskals_cpp_pytorch(weights_and_edges, args.n)
torch.cuda.synchronize()
t += time.time() - start
print(f"C++ (pytorch, gpu): {t}; avg: {t / args.num_steps}")
# Test cpp (pytorch2, cpu).
t = 0
weights_and_edges = weights_and_edges.to("cpu")
for _ in range(args.num_steps):
start = time.time()
res_pytorch = kruskals_cpp_pytorch2(weights_and_edges, args.n)
t += time.time() - start
print(f"C++ (pytorch2, cpu): {t}; avg: {t / args.num_steps}")
# Test cpp (pytorch2, gpu).
t = 0
weights_and_edges = weights_and_edges.to("cuda")
for _ in range(args.num_steps):
start = time.time()
res_pytorch = kruskals_cpp_pytorch2(weights_and_edges, args.n)
torch.cuda.synchronize()
t += time.time() - start
print(f"C++ (pytorch2, gpu): {t}; avg: {t / args.num_steps}") | 2,393 | 34.205882 | 81 | py |
torch-adaptive-imle | torch-adaptive-imle-main/nri/core/kruskals/kruskals.py | from functools import partial
import numpy as np
import torch
def get_root_pytorch(parents, node):
# find path of objects leading to the root
path = [node]
root = parents[node]
while root != path[-1]:
path.append(root)
root = parents[root]
# compress the path and return
for ancestor in path:
parents[ancestor] = root
return parents, root
def get_tree(edges, n):
# Initialize weights and edges.
weights = torch.IntTensor([1 for i in range(n)])
parents = torch.IntTensor([i for i in range(n)])
adj_matrix = torch.zeros(n-1, n)
for edge in edges:
i, j = edge
parents, root_i = get_root_pytorch(parents, i)
parents, root_j = get_root_pytorch(parents, j)
if root_i != root_j:
# Combine two forests if i and j are not in the same forest.
heavier = max([(weights[root_i], root_i), (weights[root_j], root_j)])[1]
for r in [root_i, root_j]:
if r != heavier:
weights[heavier] = weights[heavier] + weights[r]
parents[r] = heavier
# Update adjacency matrix.
adj_matrix[i][j] = 1
adj_matrix[j - 1][i] = 1
return adj_matrix
def kruskals_pytorch(weights_and_edges, n):
"""Non-batched implementation of kruskal's algorithm in Pytorch.
Easier to undertand than the batched version, but equivalent.
Args:
weights_and_edges: Shape (n * (n - 1) / 2, 3), where
weights_and_edges[i] = [weight_i, node1_i, node2_i] for edge i.
n: Number of nodes.
Returns:
Adjacency matrix with diagonal removed. Shape (n - 1, n)
"""
# Sort edges based on weights, in descending order.
sorted_edges = weights_and_edges[
(-1.0 * weights_and_edges[:,0]).argsort(), 1:].int()
return get_tree(sorted_edges, n)
def get_root_pytorch_batched(parents, node, n):
bs = parents.size(0)
arange = torch.arange(bs)
# Find path of nodes leading to the root.
path = torch.zeros_like(parents)
path[:, 0] = node
root = parents[torch.arange(bs), node]
for i in range(1, n):
path[:, i] = root
root = parents[torch.arange(bs), root]
# Compress the path and return.
for i in range(1, n):
parents[arange, path[:, i]] = root
return parents, root
def kruskals_pytorch_batched(weights_and_edges, n):
"""Batched kruskal's algorithm in Pytorch.
Args:
weights_and_edges: Shape (batch size, n * (n - 1) / 2, 3), where
weights_and_edges[.][i] = [weight_i, node1_i, node2_i] for edge i.
n: Number of nodes.
Returns:
Adjacency matrix with diagonal removed. Shape (batch size, n-1, n)
"""
# print('XXY', weights_and_edges.shape, n)
# import sys
# sys.exit(0)
device = weights_and_edges.device
batch_size = weights_and_edges.size(0)
arange = torch.arange(batch_size)
# Sort edges based on weights, in descending order.
sorted_weights = torch.argsort(
weights_and_edges[:, :, 0], -1, descending=True)
dummy = sorted_weights.unsqueeze(2).expand(
*(sorted_weights.shape + (weights_and_edges.size(2),)))
sorted_edges = torch.gather(weights_and_edges, 1, dummy)[:, :, 1:]
sorted_edges = sorted_edges.transpose(0, 1).long()
# Initialize weights and edges.
weights = torch.ones((batch_size, n)).to(device)
parents = torch.arange(n).repeat((batch_size, 1)).to(device)
adj_matrix = torch.zeros((batch_size, n - 1, n)).to(device)
for edge in sorted_edges:
i, j = edge.transpose(0, 1)
parents, root_i = get_root_pytorch_batched(parents, i, n)
parents, root_j = get_root_pytorch_batched(parents, j, n)
is_i_and_j_not_in_same_forest = (root_i != root_j).int()
# Combine two forests if i and j are not in the same forest.
is_i_heavier_than_j = (
weights[arange, root_i] > weights[arange, root_j]).int()
weights_root_i = weights[arange, root_i] + (
(weights[arange, root_j] * is_i_heavier_than_j)
* is_i_and_j_not_in_same_forest +
0.0 * (1.0 - is_i_and_j_not_in_same_forest))
parents_root_i = (
(root_i * is_i_heavier_than_j + root_j * (1 - is_i_heavier_than_j))
* is_i_and_j_not_in_same_forest +
root_i * (1 - is_i_and_j_not_in_same_forest))
weights_root_j = weights[arange, root_j] + (
weights[arange, root_i] * (1 - is_i_heavier_than_j)
* is_i_and_j_not_in_same_forest +
0.0 * (1.0 - is_i_and_j_not_in_same_forest))
parents_root_j = (
(root_i * is_i_heavier_than_j + root_j * (1 - is_i_heavier_than_j))
* is_i_and_j_not_in_same_forest +
root_j * (1 - is_i_and_j_not_in_same_forest))
weights[arange, root_i] = weights_root_i
weights[arange, root_j] = weights_root_j
parents[arange, root_i] = parents_root_i
parents[arange, root_j] = parents_root_j
# Update adjacency matrix.
adj_matrix[arange, i, j] = is_i_and_j_not_in_same_forest.float()
adj_matrix[arange, j - 1, i] = is_i_and_j_not_in_same_forest.float()
return adj_matrix
def kruskals_cpp_pytorch(weights_and_edges, n):
"""Kruskal's algorithm in C++.
Does the sorting in Pytorch, then the equivalent of the get_tree in Pytorch
above, in C++.
Args:
weights_and_edges: Shape (batch size, n * (n - 1) / 2, 3), where
weights_and_edges[.][i] = [weight_i, node1_i, node2_i] for edge i.
n: Number of nodes.
Returns:
Adjacency matrix with diagonal removed. Shape (batch size, n-1, n)
"""
# print('XXY', weights_and_edges.shape, n)
# print(weights_and_edges[0, ...])
# import sys
# sys.exit(0)
# Sort edges based on weights, in descending order.
sorted_weights = torch.argsort(
weights_and_edges[:, :, 0], -1, descending=True)
dummy = sorted_weights.unsqueeze(2).expand(
*(sorted_weights.shape + (weights_and_edges.size(2),)))
# sorted_edges is shape (batch_size, n * (n - 1) / 2, 2)
sorted_edges = torch.gather(weights_and_edges, 1, dummy)[:, :, 1:]
import kruskals_cpp
adj_matrix = kruskals_cpp.get_tree(sorted_edges.int(), n)
return adj_matrix
def kruskals_cpp_pytorch2(weights_and_edges, n):
"""Kruskal's algorithm in C++.
A different implementation of Kruskal's algorithm than all the above
implementations.
Args:
weights_and_edges: Shape (batch size, n * (n - 1) / 2, 3), where
weights_and_edges[.][i] = [weight_i, node1_i, node2_i] for edge i.
n: Number of nodes.
Returns:
Adjacency matrix with diagonal removed. Shape (batch size, n-1, n)
"""
import kruskals_cpp
adj_matrix = kruskals_cpp.kruskals(weights_and_edges, n)
return adj_matrix
if __name__ == "__main__":
# Run below tests with "python -m core.kruskals" from main folder.
# Check equivalence.
n = 4
weights = np.array([0.7601073, -0.20460297, -0.4689217,
-0.5127163, -1.9022679, 1.1506207])
vertices = np.triu_indices(n=n-1, m=n, k=1)
weights_and_edges = np.array(
[list(e) for e in zip(weights, vertices[0], vertices[1])])
res_pytorch = kruskals_pytorch(torch.Tensor(weights_and_edges), n)
res_pytorch_batched = kruskals_pytorch_batched(
torch.Tensor(weights_and_edges).unsqueeze(0), n)
res_cpp = kruskals_cpp_pytorch(
torch.Tensor(weights_and_edges).unsqueeze(0), n)
soln = np.array([[1., 1., 1., 0.],
[1., 0., 0., 0.],
[0., 0., 1., 1.]])
np.testing.assert_almost_equal(res_pytorch, soln)
np.testing.assert_almost_equal(res_pytorch_batched.squeeze(0), soln)
np.testing.assert_almost_equal(res_cpp.squeeze(0), soln)
# Also check equivalence on batch of random weights.
n = 7
bs = 100
weights = np.random.rand(bs, int(n * (n - 1) / 2))
# Pytorch.
weights = torch.tensor(weights).float()
vertices = torch.triu_indices(n-1, n, offset=1)
tiled_vertices = vertices.transpose(0, 1).repeat((weights.size(0), 1, 1)).float()
weights_and_edges = torch.cat([weights.unsqueeze(-1), tiled_vertices], axis=-1)
# Non-batched Pytorch.
res_pytorch = []
for i in range(bs):
res_pytorch.append(kruskals_pytorch(weights_and_edges[i], n))
res_pytorch = torch.stack(res_pytorch).numpy()
# Batched Pytorch.
res_pytorch_batched = kruskals_pytorch_batched(weights_and_edges, n).numpy()
# C++ (with pytorch).
res_cpp_pytorch = kruskals_cpp_pytorch(weights_and_edges, n).numpy()
# C++ (with pytorch2).
res_cpp_pytorch2 = kruskals_cpp_pytorch(weights_and_edges, n).numpy()
np.testing.assert_almost_equal(res_pytorch, res_pytorch_batched)
np.testing.assert_almost_equal(res_pytorch_batched, res_cpp_pytorch)
np.testing.assert_almost_equal(res_cpp_pytorch, res_cpp_pytorch2)
| 9,059 | 35.24 | 85 | py |
torch-adaptive-imle | torch-adaptive-imle-main/nri/core/kruskals/setup_kruskals.py | from setuptools import setup, Extension
from torch.utils import cpp_extension
setup(name="kruskals_cpp",
ext_modules=[cpp_extension.CppExtension("kruskals_cpp", ["kruskals.cpp"])],
cmdclass={"build_ext": cpp_extension.BuildExtension})
| 248 | 34.571429 | 81 | py |
IO-GEN | IO-GEN-master/test.py | import argparse
import os
import tensorflow as tf
import numpy as np
import tensorflow.keras as keras
from utils import load_of_data
from metrics import euclidean_distance_square_loss, smooth_accuracy, score
from sklearn.metrics import roc_curve, auc
# parse arguments
parser = argparse.ArgumentParser()
parser.add_argument('-s', '--split_dir', help='Directory for split')
parser.add_argument('-m', '--m', default=2, type=int, help='Number of optical flow pairs per input (default=2)')
parser.add_argument('-d', '--model_dir', default='./saved_models', help='Directory to save trained models')
parser.add_argument('-n', '--model_name', help='Model name to test, e.g.) DCAE, DSVDD, IO-GEN')
parser.add_argument('-v', '--verbose', default=1, help='verbose option, either 0 or 1')
options = parser.parse_args()
split_dir = options.split_dir
m = options.m
model_dir = options.model_dir
model_name = options.model_name
verbose = options.verbose
# necessary arguments
assert split_dir != None, 'Please specify the directory of split to use. Use "-s" argument in execution'
assert model_name != None, 'Please specify the directory of split to use. Use "-s" argument in execution'
# load data
train_x, test_stable_x, test_unstable_x = load_of_data(split_dir, m)
# unstable_x locations to confine in time
n_test_samples = [0, 666, 1333, 4000, 6666, 9333, len(test_unstable_x)]
days = ['D+1', 'D+2', 'D+3 - D+6', 'D+7 - D+10', 'D+11 - D+14', 'D+15 - D+18']
# test for different models
print('AUC Scores')
if model_name == 'DCAE':
# load model
ae = keras.models.load_model('./{}/DCAE.h5'.format(model_dir))
encoder = keras.Model(inputs=ae.input, outputs=ae.get_layer('encoded').output)
decoder = keras.Model(inputs=ae.input, outputs=ae.get_layer('decoded').output)
y_test_stable_hat = score(ae.predict(test_stable_x), test_stable_x)
for n_test_i in range(1, len(n_test_samples)):
y_test_unstable_hat = score(ae.predict(test_unstable_x[n_test_samples[n_test_i-1]:n_test_samples[n_test_i]]), \
test_unstable_x[n_test_samples[n_test_i-1]:n_test_samples[n_test_i]])
true_labels = [0.] * len(y_test_stable_hat) + [1.] * len(y_test_unstable_hat)
fpr, tpr, th = roc_curve(true_labels, np.concatenate([y_test_stable_hat, y_test_unstable_hat], axis=-1))
auc_score = auc(fpr, tpr)
print('{}: {}'.format(days[n_test_i-1], auc_score))
# test with all
y_test_unstable_hat = score(ae.predict(test_unstable_x), test_unstable_x)
true_labels = [0.] * len(y_test_stable_hat) + [1.] * len(y_test_unstable_hat)
fpr, tpr, th = roc_curve(true_labels, np.concatenate([y_test_stable_hat, y_test_unstable_hat], axis=-1))
auc_score = auc(fpr, tpr)
print('ALL: {}'.format(auc_score))
elif model_name == 'DSVDD':
# load model
ae = keras.models.load_model('./{}/DCAE.h5'.format(model_dir))
encoder = keras.Model(inputs=ae.input, outputs=ae.get_layer('encoded').output)
dsvdd = keras.models.load_model('./{}/DSVDD.h5'.format(model_dir), \
custom_objects={'euclidean_distance_square_loss':euclidean_distance_square_loss})
# Compute Center Feature
initial_outputs = encoder.predict(train_x)
center_feat = np.mean(initial_outputs, axis=0)
target_feat = np.expand_dims(center_feat, 0)
y_test_stable_hat = score(dsvdd.predict(test_stable_x), target_feat)
for n_test_i in range(1, len(n_test_samples)):
y_test_unstable_hat = score(dsvdd.predict(test_unstable_x[n_test_samples[n_test_i-1]:n_test_samples[n_test_i]]), \
target_feat)
true_labels = [0.] * len(y_test_stable_hat) + [1.] * len(y_test_unstable_hat)
fpr, tpr, th = roc_curve(true_labels, np.concatenate([y_test_stable_hat, y_test_unstable_hat], axis=-1))
auc_score = auc(fpr, tpr)
print('{}: {}'.format(days[n_test_i-1], auc_score))
# test with all
y_test_unstable_hat = score(dsvdd.predict(test_unstable_x), target_feat)
true_labels = [0.] * len(y_test_stable_hat) + [1.] * len(y_test_unstable_hat)
fpr, tpr, th = roc_curve(true_labels, np.concatenate([y_test_stable_hat, y_test_unstable_hat], axis=-1))
auc_score = auc(fpr, tpr)
print('ALL: {}'.format(auc_score))
elif model_name == 'IO-GEN':
# load model
cls = keras.models.load_model('./{}/CLASSIFIER.h5'.format(model_dir), \
custom_objects={'smooth_accuracy': smooth_accuracy, 'keras': keras})
y_test_stable_hat = cls.predict(test_stable_x).flatten()
for n_test_i in range(1, len(n_test_samples)):
y_test_unstable_hat = cls.predict(test_unstable_x[n_test_samples[n_test_i-1]:n_test_samples[n_test_i]]).flatten()
true_labels = [0.] * len(y_test_stable_hat) + [1.] * len(y_test_unstable_hat)
fpr, tpr, th = roc_curve(true_labels, np.concatenate([y_test_stable_hat, y_test_unstable_hat], axis=-1))
auc_score = auc(fpr, tpr)
print('{}: {}'.format(days[n_test_i-1], auc_score))
# test with all
y_test_unstable_hat = cls.predict(test_unstable_x).flatten()
true_labels = [0.] * len(y_test_stable_hat) + [1.] * len(y_test_unstable_hat)
fpr, tpr, th = roc_curve(true_labels, np.concatenate([y_test_stable_hat, y_test_unstable_hat], axis=-1))
auc_score = auc(fpr, tpr)
print('ALL: {}'.format(auc_score))
else:
print('Not appropriate model name')
| 5,494 | 46.37069 | 122 | py |
IO-GEN | IO-GEN-master/synthesize.py | import argparse
import os
import numpy as np
import tensorflow as tf
import tensorflow.keras as keras
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from utils import load_of_data
from models import build_DCAE, build_IO_GEN, build_classifier
from metrics import feat_matching_loss
# parse arguments
parser = argparse.ArgumentParser()
parser.add_argument('-s', '--split_dir', help='Directory for split')
parser.add_argument('-m', '--m', default=2, type=int, help='Number of optical flow pairs per input (default=2)')
parser.add_argument('-p', '--model_path', help='Path to IO-GEN model')
parser.add_argument('-f', '--fake_dir', default='./fake_imgs', help='Directory to save synthesized images')
parser.add_argument('-b', '--n_fakes', default=10, type=int, help='Number of fake optical flow pairs')
parser.add_argument('-c', '--color_map', default='Spectral', help='Colormap of matplotlib')
parser.add_argument('-i', '--inverse_value', default=0, type=int, help='Inverse value for better visualization with some colomaps')
options = parser.parse_args()
split_dir = options.split_dir
m = options.m
model_path = options.model_path
fake_dir = options.fake_dir
n_fakes = options.n_fakes
cmap = options.color_map
inverse_value = options.inverse_value
# necessary arguments
assert split_dir != None, 'Please specify the directory of split to use. Use "-s" argument in execution'
assert model_path != None, 'Please specify the path to the IO-GEN model to deploy. Use "-p" argument in execution'
if not os.path.isdir(fake_dir):
os.makedirs(fake_dir)
# load data
train_x, test_stable_x, test_unstable_x = load_of_data(split_dir, m)
# load IO-GEN
print('\n==================================')
print('Loading IO-GEN')
model = keras.models.load_model(model_path, \
custom_objects={'feat_matching_loss': feat_matching_loss})
gen = keras.Model(inputs=model.get_layer('gen').input, outputs=model.get_layer('gen').output)
latent_dim = (100,)
# generate synthetic data
for i in range(n_fakes):
print('Fake {}'.format(i))
plt.figure(figsize=(12,6))
plt.subplots_adjust(top = 1, bottom = 0, right = 1, left = 0,
hspace = 0, wspace = 0)
z = np.random.normal(loc=0, scale=1., size=(1,) + latent_dim)
flows = gen.predict(z)[0, ..., :2]
ax = plt.subplot(1, 2, 1)
if inverse_value:
ax.imshow(-abs(flows[..., 0]), cmap=cmap)
else:
ax.imshow(abs(flows[..., 0]), cmap=cmap)
ax.set_title('X')
ax.set_xticks([], [])
ax.set_yticks([], [])
ax = plt.subplot(1, 2, 2)
if inverse_value:
ax.imshow(-abs(flows[..., 1]), cmap=cmap)
else:
ax.imshow(abs(flows[..., 1]), cmap=cmap)
ax.set_title('Y')
ax.set_xticks([], [])
ax.set_yticks([], [])
plt.savefig(os.path.join(fake_dir, '{}.jpg'.format(i)))
| 2,854 | 32.197674 | 131 | py |
IO-GEN | IO-GEN-master/models.py | import tensorflow.keras as keras
import tensorflow.keras.layers as layers
from metrics import smooth_accuracy, feat_matching_loss
import numpy as np
def build_classifier(dsvdd):
filter_size = 3
n_filters_factor = 2
dsvdd.trainable = False
c_x = keras.Input(shape=dsvdd.input.shape[1:], name='c_x')
y = dsvdd(c_x)
y = layers.Lambda(lambda x: keras.backend.expand_dims(x, -1))(y)
y = layers.Conv1D(4*n_filters_factor, filter_size, padding='same')(y)
y = layers.LeakyReLU(.3)(y)
y = layers.AveragePooling1D(padding='same')(y)
y = layers.Conv1D(8*n_filters_factor, filter_size, padding='same')(y)
y = layers.LeakyReLU(.3)(y)
y = layers.AveragePooling1D(padding='same')(y)
y = layers.Conv1D(12*n_filters_factor, filter_size, padding='same')(y)
y = layers.LeakyReLU(.3)(y)
y = layers.AveragePooling1D(padding='same')(y)
y = layers.Conv1D(24*n_filters_factor, filter_size, padding='same')(y)
y = layers.LeakyReLU(.3)(y)
y = layers.AveragePooling1D(padding='same')(y)
y = layers.Conv1D(24*n_filters_factor, filter_size, padding='same')(y)
y = layers.LeakyReLU(.3)(y)
y = layers.AveragePooling1D(padding='same')(y)
y = layers.Flatten()(y)
y = layers.Dense(1)(y) # relu?
y = layers.Activation(keras.activations.sigmoid)(y)
cls = keras.Model(inputs=c_x, outputs=y, name='cls')
return cls
def build_IO_GEN(ae, dsvdd, latent_dim, lr, m):
gen_lr = lr * 2 * 2
####################
# Autoencoder and
# Encoder (Pre-trained)
####################
encoder_layer_name = 'encoded'
gen_dim = ae.get_layer(encoder_layer_name).input.shape[1:] # test, small noise input to Dense
####################
# DSC_v
####################
encoder = keras.Model(inputs=ae.input, outputs=ae.get_layer('encoded').output, name='DCAE_Encoder')
encoder = keras.models.clone_model(encoder) # re-initialize weights
l2_norm = 1e-4
d_x = keras.Input(shape=(64, 64) + (2 * m,), name='d_x')
y = encoder(d_x) # pre-trained encoder
y = layers.Flatten()(y)
y = layers.Dense(1, kernel_regularizer=keras.regularizers.l2(l2_norm), activation='sigmoid')(y)
dsc = keras.Model(inputs=d_x, outputs=y, name='DSC')
dsc.compile(loss=['binary_crossentropy'], metrics=[smooth_accuracy],
optimizer=keras.optimizers.Adam(learning_rate=lr, beta_1=0.5))
print(dsc.summary())
dsc.trainable = False
####################
# REG - SVDD
####################
dsvdd = keras.Model(inputs=dsvdd.input, outputs=dsvdd.output, name='DSVDD')
dsvdd.trainable = False
####################
# GEN
####################
y = g_x = keras.Input(shape=latent_dim, name='g_x')
flag = False
y = layers.Dense(np.prod(gen_dim), activation='relu')(y)
for i, l in enumerate(ae.layers):
if l.name == encoder_layer_name:
flag = True
if flag:
y = l(y)
gen = keras.Model(inputs=g_x, outputs=y, name='gen')
print(gen.summary())
####################
# GAN
####################
gan_opt = keras.optimizers.Adam(learning_rate=gen_lr, beta_1=.5)
g_x = keras.Input(shape=latent_dim, name='g_x')
x_star = gen(g_x)
y = dsc(x_star)
feat = dsvdd(x_star)
gan = keras.Model(g_x, [feat, y], name="gan")
gan.compile(loss={'DSVDD': feat_matching_loss, 'DSC': 'binary_crossentropy'},
metrics={'DSC': 'accuracy'}, loss_weights={'DSVDD':10., 'DSC': 1.},
optimizer=gan_opt)
return gan, gen, dsc
def build_DCAE(m, img_size=(64,64)):
use_bias = True
l2_norm = 0
x = keras.Input(shape=img_size + (2 * m,))
y = layers.Conv2D(32, 3, padding='same', activation="relu", use_bias=use_bias,
kernel_regularizer=keras.regularizers.l2(l2_norm))(x)
y = layers.MaxPooling2D(2, padding='same')(y)
y = layers.Conv2D(64, 3, padding='same', activation="relu", use_bias=use_bias,
kernel_regularizer=keras.regularizers.l2(l2_norm))(y)
y = layers.MaxPooling2D(2, padding='same')(y)
y = layers.Conv2D(128, 3, padding='same', activation="relu", use_bias=use_bias,
kernel_regularizer=keras.regularizers.l2(l2_norm))(y)
y = layers.MaxPooling2D(2, padding='same')(y)
y = layers.Conv2D(32, 3, padding='same', activation="relu", use_bias=use_bias,
kernel_regularizer=keras.regularizers.l2(l2_norm))(y) # 32
featmap_shape = y.shape[1:]
y = encoded = layers.Flatten(name='encoded')(y)
y = layers.Reshape(featmap_shape)(y)
y = layers.UpSampling2D(size=(2, 2))(y)
y = layers.Conv2D(128, 3, padding='same', activation="relu", use_bias=use_bias,
kernel_regularizer=keras.regularizers.l2(l2_norm))(y)
y = layers.UpSampling2D(size=(2, 2))(y)
y = layers.Conv2D(64, 3, padding='same', activation="relu", use_bias=use_bias,
kernel_regularizer=keras.regularizers.l2(l2_norm))(y)
y = layers.UpSampling2D(size=(2, 2))(y)
y = layers.Conv2D(32, 3, padding='same', activation="relu", use_bias=use_bias,
kernel_regularizer=keras.regularizers.l2(l2_norm))(y)
decoded = layers.Conv2D(2 * m, 3, padding='same', activation="tanh", use_bias=use_bias, name='decoded')(y)
ae = keras.Model(x, decoded, name="DCAE")
return ae
| 5,430 | 35.206667 | 110 | py |
IO-GEN | IO-GEN-master/metrics.py | import tensorflow.keras as keras
import numpy as np
def smooth_accuracy(y_true, y_pred):
y_true = keras.backend.round(y_true)
y_pred = keras.backend.round(y_pred)
correct = keras.backend.cast(keras.backend.equal(y_true, y_pred), dtype='float32')
return keras.backend.mean(correct)
def feat_matching_loss(y_true, y_pred):
mean_true_feat = keras.backend.mean(y_true, axis=0)
mean_pred_feat = keras.backend.mean(y_pred, axis=0)
return keras.backend.sum(keras.backend.square(mean_pred_feat - mean_true_feat))
def euclidean_distance_square_loss(c_vec, v_vec):
return keras.backend.sum(keras.backend.square(v_vec - c_vec), axis=-1)
def score(y_true, y_pred):
n1 = len(y_true)
n2 = len(y_pred)
y_true = np.reshape(y_true, (n1, -1))
y_pred = np.reshape(y_pred, (n2, -1))
return np.sum(np.square(y_true - y_pred), axis=-1)
| 889 | 27.709677 | 86 | py |
IO-GEN | IO-GEN-master/train.py | import argparse
import os
import tensorflow as tf
import numpy as np
import tensorflow.keras as keras
from utils import load_of_data
from models import build_DCAE, build_IO_GEN, build_classifier
from metrics import euclidean_distance_square_loss, smooth_accuracy, feat_matching_loss
# parse arguments
parser = argparse.ArgumentParser()
parser.add_argument('-s', '--split_dir', help='Directory for split')
parser.add_argument('-m', '--m', default=2, type=int, help='Number of optical flow pairs per input (default=2)')
parser.add_argument('-d', '--model_dir', default='./saved_models', help='Directory to save trained models')
parser.add_argument('-t', '--tensorboard_dir', default='./tb_logs', help='Directory to save tensorboard logs')
parser.add_argument('-v', '--verbose', default=1, help='verbose option, either 0 or 1')
options = parser.parse_args()
split_dir = options.split_dir
m = options.m
model_dir = options.model_dir
tb_dir = options.tensorboard_dir
verbose = options.verbose
# necessary arguments
assert split_dir != None, 'Please specify the directory of split to use. Use "-s" argument in execution'
# make directories if no
if not os.path.isdir(model_dir):
os.makedirs(model_dir)
if not os.path.isdir(tb_dir):
os.makedirs(tb_dir)
# load data
train_x, test_stable_x, test_unstable_x = load_of_data(split_dir, m)
# DCAE
print('\n==================================')
print('DCAE')
ae = build_DCAE(m)
if verbose:
print(ae.summary())
lr = 0.00005 * 10.
n_epochs = 750
batch_size = 16
noise_level = 0.02
saved_path = './{}/DCAE.h5'.format(model_dir)
cp_callback = keras.callbacks.ModelCheckpoint(filepath=saved_path, save_weights_only=False,
verbose=1, monitor='val_loss', mode='min', save_best_only=True)
log_dir = "./{}/DCAE".format(tb_dir)
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=log_dir, write_graph=False,
profile_batch=0)
ae.compile(loss=['mse'], optimizer=keras.optimizers.Adam(learning_rate=lr))
for e in range(n_epochs):
x_train_z = train_x + np.random.normal(scale=noise_level, size=train_x.shape)
history = ae.fit(x_train_z, train_x, validation_data=(test_stable_x, test_stable_x),
batch_size=batch_size, initial_epoch=e,
epochs=e+1, callbacks=[cp_callback, tensorboard_callback], verbose=2)
# DSVDD
print('\n==================================')
print('DSVDD')
model = keras.models.load_model('./{}/DCAE.h5'.format(model_dir))
encoder = keras.Model(inputs=model.input, outputs=model.get_layer('encoded').output)
if verbose:
print(encoder.summary())
# Compute central feature c
initial_outputs = encoder.predict(train_x)
center_feat = np.mean(initial_outputs, axis=0)
target_feat = np.expand_dims(center_feat, 0)
target_feat_train = np.repeat(target_feat, len(train_x), axis=0)
target_feat_val = np.repeat(target_feat, len(test_stable_x), axis=0)
saved_path = './{}/DSVDD.h5'.format(model_dir)
cp_callback = keras.callbacks.ModelCheckpoint(filepath=saved_path, save_weights_only=False, verbose=1,
monitor='val_loss', mode='min', save_best_only=True)
log_dir = "./{}/DSVDD".format(tb_dir)
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=log_dir, write_graph=False,
profile_batch=0)
n_epochs = 160
batch_size = 16
lr = 0.00005
encoder.compile(loss=[euclidean_distance_square_loss], optimizer=keras.optimizers.Adam(learning_rate=lr))
for e in range(n_epochs):
print('***********\nEpoch {}/{}'.format(e+1, n_epochs))
encoder.fit(train_x, target_feat_train, validation_data=(test_stable_x, target_feat_val),
batch_size=batch_size, initial_epoch=e, epochs=e+1, callbacks=[cp_callback, tensorboard_callback],
verbose=2)
# IO-GEN
print('\n==================================')
print('IO-GEN')
lr = 0.000005 * .5 * .5
latent_dim = (100,)
ae = keras.models.load_model('./{}/DCAE.h5'.format(model_dir))
dsvdd = keras.models.load_model('./{}/DSVDD.h5'.format(model_dir), \
custom_objects={'euclidean_distance_square_loss':euclidean_distance_square_loss})
gan, gen, dsc = build_IO_GEN(ae, dsvdd, latent_dim, lr, m)
if verbose:
print(gan.summary())
# prepare E(v)
encoder = keras.Model(inputs=ae.input, outputs=ae.get_layer('encoded').output)
initial_outputs = encoder.predict(train_x)
center_feat = np.mean(initial_outputs, axis=0)
target_feat = np.expand_dims(center_feat, 0)
target_feat_train = np.repeat(target_feat, len(train_x), axis=0)
print(target_feat_train.shape)
n_epochs = 20000
batch_size = 16 #16
noise_level = 0
v_mean, v_std = 0, 1
log_dir = "./{}/IO-GEN".format(tb_dir)
tb_writer = tf.summary.create_file_writer(log_dir)
tb_writer.set_as_default()
for e in range(n_epochs):
print('***********\nEpoch {}/{}'.format(e+1, n_epochs))
#####################
# DSC
#####################
# Real
#####################
real_train_idx = np.random.randint(0, high=len(train_x), size=batch_size)
real_train_x = train_x[real_train_idx] \
+ np.random.normal(scale=noise_level, size=train_x[:batch_size].shape)
real_labels = np.ones((batch_size, 1)) - np.random.uniform(0., .1, size=(batch_size, 1))
dsc_real_loss, dsc_real_acc = dsc.train_on_batch(real_train_x, real_labels)
tf.summary.scalar('DSC/Real_Ent', data=dsc_real_loss, step=e)
tf.summary.scalar('DSC/Real_Acc', data=dsc_real_acc, step=e)
#####################
# Fake
#####################
z = np.random.normal(loc=v_mean, scale=v_std, size=(batch_size,) + latent_dim)
fake_train_x = gen.predict(z) \
+ np.random.normal(scale=noise_level, size=train_x[:batch_size].shape)
fake_labels = np.zeros((batch_size, 1)) + np.random.uniform(0., .1, size=(batch_size, 1))
dsc_fake_loss, dsc_fake_acc = dsc.train_on_batch(fake_train_x, fake_labels)
tf.summary.scalar('DSC/Fake_Ent', data=dsc_fake_loss, step=e)
tf.summary.scalar('DSC/Fake_Acc', data=dsc_fake_acc, step=e)
#####################
# GEN
#####################
z = np.random.normal(loc=v_mean, scale=v_std, size=(batch_size,) + latent_dim)
loss, feat_loss, gen_loss, gen_acc = gan.train_on_batch(z, \
[target_feat_train[:batch_size], np.ones((batch_size, 1))])
tf.summary.scalar('GEN_FM/DSVDD_Loss', data=feat_loss, step=e)
tf.summary.scalar('GEN/Loss', data=gen_loss, step=e)
tf.summary.scalar('GEN/Acc', data=gen_acc, step=e)
print('Dsc')
print('RealLoss={}, FakeLoss={}'.format(dsc_real_loss, dsc_fake_loss))
print('RealAcc={}, FakeAcc={}'.format(dsc_real_acc, dsc_fake_acc))
print('\nIO-GEN')
print('Loss={}'.format(gen_loss))
print('InvAcc={}'.format(gen_acc))
print('DSVDD_Loss={}\n'.format(feat_loss))
if e % 500 == 0:
z = np.random.normal(loc=v_mean, scale=v_std, size=(batch_size,) + latent_dim)
x_star = np.asarray(gen.predict(z))
x_star = (x_star - np.min(x_star))/(np.max(x_star) - np.min(x_star))
tf.summary.image('{} x^* Ch1'.format(batch_size), x_star[:][..., 0:1], max_outputs=batch_size, step=e)
tf.summary.image('{} x^* Ch2'.format(batch_size), x_star[:][..., 1:2], max_outputs=batch_size, step=e)
tf.summary.flush()
saved_path = './{}/IO-GEN.h5'.format(model_dir)
gan.save(saved_path)
# Classifier
print('\n==================================')
print('CLASSIFIER')
model = keras.models.load_model('./{}/IO-GEN.h5'.format(model_dir), \
custom_objects={'feat_matching_loss': feat_matching_loss})
gen = keras.Model(inputs=model.get_layer('gen').input, outputs=model.get_layer('gen').output)
dsvdd = keras.models.load_model('./{}/DSVDD.h5'.format(model_dir), \
custom_objects={'euclidean_distance_square_loss':euclidean_distance_square_loss})
dsvdd = keras.Model(inputs=dsvdd.input, outputs=dsvdd.output, name='DSVDD')
cls = build_classifier(dsvdd)
lr = 0.005 * .05 * .5
cls.compile(loss=['binary_crossentropy'], metrics=[smooth_accuracy], optimizer=keras.optimizers.Adam(learning_rate=lr))
if verbose:
print(cls.summary())
n_epochs = 40
batch_size = 32
saved_path = './{}/CLASSIFIER.h5'.format(model_dir)
cp_callback = keras.callbacks.ModelCheckpoint(filepath=saved_path, save_weights_only=False, verbose=1,
monitor='val_smooth_accuracy', mode='max', save_best_only=True)
log_dir = "./{}/CLASSIFIER".format(tb_dir)
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=log_dir, write_graph=False,
profile_batch=0)
for e in range(n_epochs):
print('***********\nEpoch {}/{}'.format(e+1, n_epochs))
########
# Train
########
z = np.random.normal(loc=0, scale=1, size=(train_x.shape[0], gen.input.shape[-1]))
fake_train_x = gen.predict(z) #+ np.random.normal(scale=noise_level, size=train_x.shape)
real_train_x = train_x #
fake_y_train = np.zeros((len(fake_train_x), 1))
real_y_train = np.ones((len(train_x), 1))
train_x_samples = np.concatenate([real_train_x, fake_train_x], 0)
train_x_labels = np.concatenate([real_y_train, fake_y_train], 0)
########
# Val
########
z = np.random.normal(loc=0, scale=1, size=(test_unstable_x.shape[0], gen.input.shape[-1]))
fake_test_unstable_x = gen.predict(z) #+ np.random.normal(scale=noise_level, size=test_unstable_x.shape)
real_test_unstable_x = test_unstable_x #+ np.random.normal(scale=noise_level, size=test_unstable_x.shape)
fake_y_val = np.zeros((len(fake_test_unstable_x), 1))
real_y_val = np.ones((len(test_unstable_x), 1))
test_unstable_x_samples = np.concatenate([real_test_unstable_x, fake_test_unstable_x], 0)
test_unstable_x_labels = np.concatenate([real_y_val, fake_y_val], 0)
# Fit
cls.fit(train_x_samples, train_x_labels, validation_data=(test_unstable_x_samples, test_unstable_x_labels),
batch_size=batch_size, initial_epoch=e, epochs=e+1,
callbacks=[cp_callback, tensorboard_callback], verbose=2)
| 10,210 | 38.731518 | 119 | py |
Multi-Fidelity-Deep-Active-Learning | Multi-Fidelity-Deep-Active-Learning-main/dmfdal_2f/train.py | from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import argparse
import yaml
from lib import utils
from model.pytorch.supervisor import Supervisor
import random
import numpy as np
import os
import pickle
def main(args):
with open(args.config_filename) as f:
supervisor_config = yaml.safe_load(f)
max_itr = supervisor_config.get('train').get('max_itr', 25) #25
seed = supervisor_config.get('train').get('seed', 1) #25
costs = supervisor_config.get('train').get('costs')
opt_rate = supervisor_config.get('train').get('opt_lr')
acq_weight = supervisor_config.get('train').get('acq_weight')
num_sample = supervisor_config.get('train').get('num_sample')
data_type = supervisor_config.get('data').get('data_type')
method = supervisor_config.get('train').get('method')
fidelity_weight = supervisor_config.get('train').get('fidelity_weight')
np.random.seed(seed)
random.seed(seed)
data = utils.load_dataset(**supervisor_config.get('data'))
supervisor = Supervisor(random_seed=seed, iteration=0, max_itr = max_itr, **supervisor_config)
# if not os.path.exists('seed%d/reward_list' % (i)): #for nRmse
# os.makedirs('seed%d/reward_list' % (i))
if not os.path.exists('results'): #for cost
os.makedirs('results')
m_batch_list = []
fidelity_info_list = []
fidelity_query_list = []
reg_info_list = []
l2_y_preds_all = []
test_nll_list = []
test_rmse_list = []
test_nrmse_list = []
for itr in range(max_itr):
supervisor._data = data
supervisor.iteration = itr
l1_x_s, l1_y_s, l2_x_s, l2_y_s, m_batch, fidelity_info, fidelity_query, reg_info, test_nll, test_rmse, test_nrmse, l2_y_truths, l2_y_preds_mu = supervisor.train()
selected_data = {}
selected_data['l1_x'] = l1_x_s
selected_data['l1_y'] = l1_y_s
selected_data['l2_x'] = l2_x_s
selected_data['l2_y'] = l2_y_s
search_config = supervisor_config.get('data').copy()
search_config['selected_data'] = selected_data
search_config['previous_data'] = data
data = utils.generate_new_trainset(**search_config)
m_batch_list.append(m_batch)
fidelity_info_list.append(fidelity_info)
fidelity_query_list.append(fidelity_query)
reg_info_list.append(reg_info)
test_nll_list.append(test_nll)
test_rmse_list.append(test_rmse)
test_nrmse_list.append(test_nrmse)
# m_batch = np.stack(m_batch_list)
# fidelity_info = np.stack(fidelity_info_list)
# fidelity_query = np.stack(fidelity_query_list).squeeze()
# reg_info = np.stack(reg_info_list)
# test_nll = np.stack(test_nll_list)
# test_rmse = np.stack(test_rmse_list)
# test_nrmse = np.stack(test_nrmse_list)
dictionary = {'fidelity': m_batch_list, 'score': fidelity_info_list, 'x': fidelity_query_list, 'weighted_score': reg_info_list, 'nll': test_nll_list, 'rmse': test_rmse_list, 'nrmse': test_nrmse_list}
with open('results/exp_'+str(data_type)+'_opt_'+str(method)+'_fweight_'+str(fidelity_weight)+'_optlr'+str(opt_rate)+'_weight'+str(acq_weight)+'_sample'+str(num_sample)+'_cost'+str(costs[-1])+'_seed'+str(seed)+'.pkl', 'wb') as f:
pickle.dump(dictionary, f)
print('l2_y_truths.shape',l2_y_truths.shape)
print('l2_y_preds_mu.shape',l2_y_preds_mu.shape)
l2_y_preds_all.append(l2_y_preds_mu)
print('l2_y_preds_all size: ', len(l2_y_preds_all))
np.save('results/exp'+str(data_type)+'_opt'+str(method)+'_sample'+str(num_sample)+'_seed'+str(seed)+'truths.npz', l2_y_truths)
np.save('results/exp'+str(data_type)+'_opt'+str(method)+'_sample'+str(num_sample)+'_seed'+str(seed)+'preds_mu.npz', l2_y_preds_all)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--config_filename', default='data/model/seed1.yaml', type=str,
help='Configuration filename for restoring the model.')
parser.add_argument('--use_cpu_only', default=False, type=bool, help='Set to true to only use cpu.')
args = parser.parse_args()
main(args)
| 4,267 | 36.769912 | 236 | py |
Multi-Fidelity-Deep-Active-Learning | Multi-Fidelity-Deep-Active-Learning-main/dmfdal_2f/model/pytorch/loss.py | import torch
import torch.nn as nn
from scipy.stats import multivariate_normal
import numpy as np
def nll_loss(pred_mu, pred_cov, y):
pred_std = torch.sqrt(pred_cov)
gaussian = torch.distributions.Normal(pred_mu, pred_std)
nll = -gaussian.log_prob(y)
nll = torch.mean(nll)
return nll
def nll_metric(pred_mu, pred_cov, y):
pred_mu = torch.from_numpy(pred_mu)
pred_cov = torch.from_numpy(pred_cov)
y = torch.from_numpy(y)
pred_std = torch.sqrt(pred_cov)
gaussian = torch.distributions.Normal(pred_mu, pred_std)
nll = -gaussian.log_prob(y)
nll = torch.mean(nll).cpu().detach().numpy()
return nll
def rmse_metric(y_pred, y_true):
loss = np.sqrt(np.mean(np.square(y_pred - y_true)))
return loss
# def nonormalized_mae_metric(y_pred, y_true):
# loss = np.abs(np.exp(y_pred) - np.exp(y_true))
# loss[loss != loss] = 0
# loss = loss.mean()
# return loss
# def mse_metric(y_pred, y_true):
# loss0 = (y_pred-y_true)**2
# loss0[loss0 != loss0] = 0
# loss = np.mean(loss0)
# return loss
def kld_gaussian_loss(z_mean_all, z_var_all, z_mean_context, z_var_context):
"""Analytical KLD between 2 Gaussians."""
mean_q, var_q, mean_p, var_p = z_mean_all, z_var_all, z_mean_context, z_var_context
std_q = torch.sqrt(var_q)
std_p = torch.sqrt(var_p)
p = torch.distributions.Normal(mean_p, std_p)
q = torch.distributions.Normal(mean_q, std_q)
# print('torch.distributions.kl_divergence(q, p)',torch.distributions.kl_divergence(q, p).shape)
return torch.mean(torch.distributions.kl_divergence(q, p))
# return torch.mean(torch.sum(torch.distributions.kl_divergence(q, p),dim=1))
| 1,747 | 33.27451 | 100 | py |
Multi-Fidelity-Deep-Active-Learning | Multi-Fidelity-Deep-Active-Learning-main/dmfdal_2f/model/pytorch/model.py | import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
# device = torch.device("cuda:5")
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
class MLP_Encoder(nn.Module):
def __init__(self,
in_dim,
out_dim,
hidden_layers=2,
hidden_dim=32):
nn.Module.__init__(self)
layers = [nn.Linear(in_dim, hidden_dim), nn.ELU()]
for _ in range(hidden_layers - 1):
# layers.append(nn.LayerNorm(hidden_dim))
layers += [nn.Linear(hidden_dim, hidden_dim), nn.ELU()]
# layers.append(nn.BatchNorm1d(hidden_dim))
layers.append(nn.Linear(hidden_dim, hidden_dim))
self.model = nn.Sequential(*layers)
self.mean_out = nn.Linear(hidden_dim, out_dim)
self.cov_out = nn.Linear(hidden_dim, out_dim)
self.cov_m = nn.Sigmoid()
def forward(self, x):
# x = torch.cat([x,adj],dim=-1)
output = self.model(x)
mean = self.mean_out(output)
# cov = self.cov_m(self.cov_out(output))
cov = 0.1+ 0.9*self.cov_m(self.cov_out(output))
return mean, cov
class MLP_Decoder(nn.Module):
def __init__(self,
in_dim,
out_dim,
hidden_layers=2,
hidden_dim=32):
nn.Module.__init__(self)
layers = [nn.Linear(in_dim, hidden_dim), nn.ELU()]
for _ in range(hidden_layers - 1):
# layers.append(nn.LayerNorm(hidden_dim))
layers += [nn.Linear(hidden_dim, hidden_dim), nn.ELU()]
# layers.append(nn.BatchNorm1d(hidden_dim))
layers.append(nn.Linear(hidden_dim, hidden_dim))
self.model = nn.Sequential(*layers)
self.mean_out = nn.Linear(hidden_dim, out_dim)
self.cov_out = nn.Linear(hidden_dim, out_dim)
self.cov_m = nn.Softplus()
def forward(self, x):
# x = torch.cat([x,adj],dim=-1)
output = self.model(x)
mean = self.mean_out(output)
cov = self.cov_m(self.cov_out(output))
# cov = torch.exp(self.cov_out(output))
return mean, cov
class Model(nn.Module):
def __init__(self, logger, **model_kwargs):
super().__init__()
self.device = torch.device(model_kwargs.get('device')) #"cuda:5"
self.hidden_layers = int(model_kwargs.get('hidden_layers',2))
self.z_dim = int(model_kwargs.get('z_dim',32))
self.input_dim = int(model_kwargs.get('input_dim', 3))
self.l1_output_dim = int(model_kwargs.get('l1_output_dim', 256))
self.l2_output_dim = int(model_kwargs.get('l2_output_dim', 1024))
self.hidden_dim = int(model_kwargs.get('hidden_dim', 32))
self.encoder_output_dim = self.z_dim
self.decoder_input_dim = self.z_dim + self.input_dim
self.context_percentage_low = float(model_kwargs.get('context_percentage_low', 0.2))
self.context_percentage_high = float(model_kwargs.get('context_percentage_high', 0.5))
self.l1_encoder_model_local = MLP_Encoder(self.input_dim+self.l1_output_dim, self.encoder_output_dim, self.hidden_layers, self.hidden_dim)
self.l1_encoder_model_global = MLP_Encoder(self.input_dim+self.l1_output_dim, self.encoder_output_dim, self.hidden_layers, self.hidden_dim)
self.l2_encoder_model_local = MLP_Encoder(self.input_dim+self.l2_output_dim, self.encoder_output_dim, self.hidden_layers, self.hidden_dim)
self.l2_encoder_model_global = MLP_Encoder(self.input_dim+self.l2_output_dim, self.encoder_output_dim, self.hidden_layers, self.hidden_dim)
self.l1_decoder_model = MLP_Decoder(self.decoder_input_dim, self.l1_output_dim, self.hidden_layers, self.hidden_dim)
self.l2_decoder_model = MLP_Decoder(self.decoder_input_dim, self.l2_output_dim, self.hidden_layers, self.hidden_dim)
# self.z2_z1_agg = MLP_Z1Z2_Encoder(self.z_dim, self.z_dim)
self._logger = logger
def split_context_target(self, x, y, context_percentage_low, context_percentage_high):
"""Helper function to split randomly into context and target"""
context_percentage = np.random.uniform(context_percentage_low,context_percentage_high)
# if level == 1:
# node_dim = 18
# elif level == 2:
# node_dim = 85
# x = x.reshape(-1,node_dim,x.shape[-1])
# y = y.reshape(-1,node_dim,y.shape[-1])
# adj= adj.reshape(-1,node_dim,node_dim)
n_context = int(x.shape[0]*context_percentage)
ind = np.arange(x.shape[0])
mask = np.random.choice(ind, size=n_context, replace=False)
others = np.delete(ind,mask)
return x[mask], y[mask], x[others], y[others]
def sample_z(self, mean, var, n=1):
"""Reparameterisation trick."""
eps = torch.autograd.Variable(var.data.new(n,var.size(0)).normal_()).to(self.device)
std = torch.sqrt(var)
return torch.unsqueeze(mean, dim=0) + torch.unsqueeze(std, dim=0) * eps
def xy_to_r_local(self, x, y, level):
if level == 1:
r_mu, r_cov = self.l1_encoder_model_local(torch.cat([x, y],dim=-1))
elif level == 2:
r_mu, r_cov = self.l2_encoder_model_local(torch.cat([x, y],dim=-1))
return r_mu, r_cov
def xy_to_r_global(self, x, y, level):
if level == 1:
r_mu, r_cov = self.l1_encoder_model_global(torch.cat([x, y],dim=-1))
elif level == 2:
r_mu, r_cov = self.l2_encoder_model_global(torch.cat([x, y],dim=-1))
return r_mu, r_cov
def z_to_y(self, x, zs, level):
# outputs = []
if level == 1:
output = self.l1_decoder_model(torch.cat([x,zs], dim=-1))
elif level == 2:
output = self.l2_decoder_model(torch.cat([x,zs], dim=-1))
return output
def ba_z_agg(self, r_mu, r_cov):
# r_mu = torch.swapaxes(r_mu,0,1)
# r_cov = torch.swapaxes(r_cov,0,1)
z_mu = torch.zeros(r_mu[0].shape).to(self.device)
z_cov = torch.ones(r_cov[0].shape).to(self.device)
# r_mu = torch.cat([r_mu_k, r_mu_g],0)
# r_cov = torch.cat([r_cov_k, r_cov_g],0)
v = r_mu - z_mu
w_cov_inv = 1 / r_cov
z_cov_new = 1 / (1 / z_cov + torch.sum(w_cov_inv, dim=0))
z_mu_new = z_mu + z_cov_new * torch.sum(w_cov_inv * v, dim=0)
return z_mu_new, z_cov_new
def forward(self, l1_x_all=None, l1_y_all=None, l2_x_all=None, l2_y_all=None, x_ref=None, l1_y_ref=None, l2_y_ref=None, test=False, l1_x_test=None, l2_x_test=None, l1_z_mu_all=None, l1_z_cov_all=None, l2_z_mu_all=None, l2_z_cov_all=None):
if test==False:
self._logger.debug("starting point complete, starting split source and target")
#first half for context, second for target
l1_x_c,l1_y_c,l1_x_t,l1_y_t = self.split_context_target(l1_x_all,l1_y_all, self.context_percentage_low, self.context_percentage_high)
l2_x_c,l2_y_c,l2_x_t,l2_y_t = self.split_context_target(l2_x_all,l2_y_all, self.context_percentage_low, self.context_percentage_high)
self._logger.debug("data split complete, starting encoder")
# compute ref distance
# print('x_ref.shape, l1_y_ref.shape', x_ref.shape, l1_y_ref.shape)
l1_r_mu_ref, l1_r_cov_ref = self.xy_to_r_global(x_ref, l1_y_ref, level=1)
l2_r_mu_ref, l2_r_cov_ref = self.xy_to_r_global(x_ref, l2_y_ref, level=2)
#l1_encoder
l1_r_mu_all_k, l1_r_cov_all_k = self.xy_to_r_local(l1_x_all, l1_y_all, level=1)
l1_r_mu_c_k, l1_r_cov_c_k = self.xy_to_r_local(l1_x_c, l1_y_c, level=1)
l1_r_mu_all_g, l1_r_cov_all_g = self.xy_to_r_global(l1_x_all, l1_y_all, level=1)
l1_r_mu_c_g, l1_r_cov_c_g = self.xy_to_r_global(l1_x_c, l1_y_c, level=1)
#l2_encoder
l2_r_mu_all_k, l2_r_cov_all_k = self.xy_to_r_local(l2_x_all, l2_y_all, level=2)
l2_r_mu_c_k, l2_r_cov_c_k = self.xy_to_r_local(l2_x_c, l2_y_c, level=2)
l2_r_mu_all_g, l2_r_cov_all_g = self.xy_to_r_global(l2_x_all, l2_y_all, level=2)
l2_r_mu_c_g, l2_r_cov_c_g = self.xy_to_r_global(l2_x_c, l2_y_c, level=2)
l1_r_mu_all = torch.cat([l1_r_mu_all_k, l1_r_mu_all_g, l2_r_mu_all_g],0)
l2_r_mu_all = torch.cat([l2_r_mu_all_k, l1_r_mu_all_g, l2_r_mu_all_g],0)
l1_r_cov_all = torch.cat([l1_r_cov_all_k, l1_r_cov_all_g, l2_r_cov_all_g],0)
l2_r_cov_all = torch.cat([l2_r_cov_all_k, l1_r_cov_all_g, l2_r_cov_all_g],0)
l1_r_mu_c = torch.cat([l1_r_mu_c_k, l1_r_mu_c_g, l2_r_mu_all_g],0)
l2_r_mu_c = torch.cat([l2_r_mu_c_k, l1_r_mu_all_g, l2_r_mu_c_g],0)
l1_r_cov_c = torch.cat([l1_r_cov_c_k, l1_r_cov_c_g, l2_r_cov_all_g],0)
l2_r_cov_c = torch.cat([l2_r_cov_c_k, l1_r_cov_all_g, l2_r_cov_c_g],0)
l1_z_mu_all, l1_z_cov_all = self.ba_z_agg(l1_r_mu_all, l1_r_cov_all)
l1_z_mu_c, l1_z_cov_c = self.ba_z_agg(l1_r_mu_c, l1_r_cov_c)
l2_z_mu_all, l2_z_cov_all = self.ba_z_agg(l2_r_mu_all, l2_r_cov_all)
l2_z_mu_c, l2_z_cov_c = self.ba_z_agg(l2_r_mu_c, l2_r_cov_c)
#sample z
l1_zs = self.sample_z(l1_z_mu_all, l1_z_cov_all, l1_x_t.size(0))
l2_zs = self.sample_z(l2_z_mu_all, l2_z_cov_all, l2_x_t.size(0))
#l1_decoder, l2_decoder
self._logger.debug("Encoder complete, starting decoder")
l1_output_mu, l1_output_cov = self.z_to_y(l1_x_t,l1_zs, level=1)
l2_output_mu, l2_output_cov = self.z_to_y(l2_x_t,l2_zs, level=2)
l1_truth = l1_y_t
l2_truth = l2_y_t
self._logger.debug("Decoder complete")
# if batches_seen == 0:
# self._logger.info(
# "Total trainable parameters {}".format(count_parameters(self))
# )
return l1_output_mu, l1_output_cov, l2_output_mu, l2_output_cov, l1_truth, l2_truth, l1_z_mu_all, l1_z_cov_all, l1_z_mu_c, l1_z_cov_c, l2_z_mu_all, l2_z_cov_all, l2_z_mu_c, l2_z_cov_c, l1_r_mu_ref, l1_r_cov_ref, l2_r_mu_ref, l2_r_cov_ref
else:
# l1_output_mu, l1_output_cov, l2_output_mu, l2_output_cov = None, None, None, None
# l1_r_mu_all_k1, l1_r_cov_all_k1 = self.xy_to_r_local(l1_x_all, l1_y_all, level=1)
# l1_r_mu_all_g1, l1_r_cov_all_g1 = self.xy_to_r_global(l1_x_all, l1_y_all, level=1)
# l2_r_mu_all_k2, l2_r_cov_all_k2 = self.xy_to_r_local(l2_x_all, l2_y_all, level=2)
# l2_r_mu_all_g2, l2_r_cov_all_g2 = self.xy_to_r_global(l2_x_all, l2_y_all, level=2)
# l1_z_mu_all, l1_z_cov_all = self.ba_z_agg(l1_r_mu_all_k1, l1_r_cov_all_k1, l1_r_mu_all_g1, l1_r_cov_all_g1)
# l2_z_mu_all, l2_z_cov_all = self.ba_z_agg(l2_r_mu_all_k2, l2_r_cov_all_k2, l2_r_mu_all_g2, l2_r_cov_all_g2)
# l1_r_mu_all, l1_r_cov_all = self.xy_to_r(l1_x_all, l1_y_all, level=1)
# if l1_x_all is not None:
l1_zs = self.sample_z(l1_z_mu_all, l1_z_cov_all, l1_x_test.size(0))
l1_output_mu, l1_output_cov = self.z_to_y(l1_x_test, l1_zs, level=1)
# if l2_x_all is not None:
l2_zs = self.sample_z(l2_z_mu_all, l2_z_cov_all, l2_x_test.size(0))
l2_output_mu, l2_output_cov = self.z_to_y(l2_x_test, l2_zs, level=2)
return l1_output_mu, l1_output_cov, l2_output_mu, l2_output_cov
| 11,573 | 43.860465 | 249 | py |
Multi-Fidelity-Deep-Active-Learning | Multi-Fidelity-Deep-Active-Learning-main/dmfdal_2f/model/pytorch/supervisor.py | import os
import time
import numpy as np
import torch
from torch.utils.tensorboard import SummaryWriter
from lib import utils
from model.pytorch.model import Model
from model.pytorch.loss import nll_loss
from model.pytorch.loss import nll_metric
from model.pytorch.loss import rmse_metric
# from model.pytorch.loss import nonormalized_mae_metric
from model.pytorch.loss import kld_gaussian_loss
from torch.utils.tensorboard import SummaryWriter
import model.pytorch.dataset_active as dataset
from torch.optim import LBFGS
import torch.nn as nn
import copy
import sys
import csv
# device = torch.device("cuda:1")
class Supervisor:
def __init__(self, random_seed, **kwargs):
self._kwargs = kwargs
self._data_kwargs = kwargs.get('data')
self._data_type = self._data_kwargs.get('data_type')
self.synD = dataset.Dataset(self._data_type, random_seed)
self._model_kwargs = kwargs.get('model')
self._train_kwargs = kwargs.get('train')
self.max_grad_norm = self._train_kwargs.get('max_grad_norm', 1.)
self.random_seed = random_seed
torch.manual_seed(self.random_seed)
torch.cuda.manual_seed(self.random_seed)
np.random.seed(self.random_seed)
self.costs = self._train_kwargs.get('costs', [1,3])
self.acq_weight = self._train_kwargs.get('acq_weight', 1e-2)
self.method = self._train_kwargs.get('method')
self.num_sample = int(self._train_kwargs.get('num_sample', 100))
self.fidelity_weight = self._train_kwargs.get('fidelity_weight', 1.)
# logging.
self._log_dir = self._get_log_dir(kwargs, self.random_seed, self.costs, self.acq_weight, self.num_sample, self._data_type, self.method, self.fidelity_weight)
# self._writer = SummaryWriter('runs/' + self._log_dir)
log_level = self._kwargs.get('log_level', 'INFO')
self._logger = utils.get_logger(self._log_dir, __name__, 'info.log', level=log_level)
# data set
self._data = utils.load_dataset(**self._data_kwargs)
self.x_scaler = self._data['l1_x_scaler']
self.l1_y_scaler = self._data['l1_y_scaler']
self.l2_y_scaler = self._data['l2_y_scaler']
self.input_dim = int(self._model_kwargs.get('input_dim', 3))
self.l1_output_dim = int(self._model_kwargs.get('l1_output_dim', 256))
self.l2_output_dim = int(self._model_kwargs.get('l2_output_dim', 1024))
self.z_dim = int(self._model_kwargs.get('z_dim',32))
self.num_batches = None #int(0)
self.device_num = self._model_kwargs.get('device') #"cuda:5"
self.device = torch.device(self.device_num)
self.budget = int(self._train_kwargs.get('budget', 20))
self.opt_lr = self._train_kwargs.get('opt_lr', 1e-4)
# self.opt_iter = self._train_kwargs.get('opt_iter', 2000)
self.opt_every_n_epochs = self._train_kwargs.get('opt_every_n_epochs', 1)
# setup model
model = Model(self._logger, **self._model_kwargs)
self.model = model.cuda(self.device) if torch.cuda.is_available() else model
self._logger.info("Model created")
self._epoch_num = self._train_kwargs.get('epoch', 0)
self._opt_epoch_num = self._train_kwargs.get('opt_epoch', 0)
self._opt_epochs = self._train_kwargs.get('opt_epochs', 1000)
@staticmethod
def _get_log_dir(kwargs, random_seed, costs, acq_weight, num_sample, data_type, method, fidelity_weight):
log_dir = kwargs['train'].get('log_dir')
if log_dir is None:
learning_rate = kwargs['train'].get('base_lr')
opt_rate = kwargs['train'].get('opt_lr')
# max_diffusion_step = kwargs['model'].get('max_diffusion_step')
# num_rnn_layers = kwargs['model'].get('num_rnn_layers')
# rnn_units = kwargs['model'].get('rnn_units')
# structure = '-'.join(
# ['%d' % rnn_units for _ in range(num_rnn_layers)])
# horizon = kwargs['model'].get('horizon')
run_id = 'exp_%s_opt_%s_fweight_%g_optlr_%g_lr_%g_weight_%g_sample_%d_cost_%d_seed_%d_%s/' % (
data_type, method, fidelity_weight, opt_rate, learning_rate,
acq_weight, num_sample, costs[-1], random_seed, time.strftime('%m%d%H%M%S'))
base_dir = kwargs.get('base_dir')
log_dir = os.path.join(base_dir, run_id)
if not os.path.exists(log_dir):
os.makedirs(log_dir)
return log_dir
# def save_model(self, epoch, l1_z_total, l2_z_total, outputs, saved_model, val_nll, nll, mae, non_mae):
# if not os.path.exists('weights'):
# os.makedirs('weights')
# if not os.path.exists('mean_mfhnp_results'):
# os.makedirs('mean_mfhnp_results')
# config = dict(self._kwargs)
# config['model_state_dict'] = saved_model
# config['epoch'] = epoch
# torch.save(config, 'weights/model_seed%d_epo%d.tar' % (self.random_seed, epoch))
# torch.save(l1_z_total, 'weights/l1_z_seed%d_epo%d.tar' % (self.random_seed, epoch))
# torch.save(l2_z_total, 'weights/l2_z_seed%d_epo%d.tar' % (self.random_seed, epoch))
# np.savez_compressed('mean_mfhnp_results/test_seed%d.npz'% (self.random_seed), **outputs)
# self._logger.info("Saved model at {}".format(epoch))
# with open(r'mean_mfhnp_results/metric_seed%d.csv'% (self.random_seed), 'a') as f:
# writer = csv.writer(f)
# writer.writerow([nll, non_mae])
# return 'weights/model_seed%d_epo%d.tar' % (self.random_seed, epoch)
def train(self, **kwargs):
kwargs.update(self._train_kwargs)
#initialize model weights
# for name, param in self.model.named_parameters():
# if 'weight' in name:
# nn.init.xavier_uniform_(param)
l1_z_mu_all, l1_z_cov_all, l2_z_mu_all, l2_z_cov_all, l1_test_nll, l1_test_rmse, l1_test_nrmse, l2_test_nll, l2_test_rmse, l2_test_nrmse, l2_y_truths, l2_y_preds_mu = self._train(**kwargs)
self._logger.info('l1_z_mu_all: {}, l1_z_cov_all: {}, l2_z_mu_all: {}, l2_z_cov_all: {}'.format(l1_z_mu_all, l1_z_cov_all, l2_z_mu_all, l2_z_cov_all))
if self.method == "gradient":
l1_x_s, l2_x_s, m_batch, fidelity_info, fidelity_query, reg_info = self.submod_batch_query(l1_z_mu_all, l1_z_cov_all, l2_z_mu_all, l2_z_cov_all, self.budget)
elif self.method == "random":
l1_x_s, l2_x_s, m_batch, fidelity_info, fidelity_query, reg_info = self.random_batch_query(l1_z_mu_all, l1_z_cov_all, l2_z_mu_all, l2_z_cov_all, self.budget)
mu = self.x_scaler.mean
std = self.x_scaler.std
fidelity_query = fidelity_query * std + mu
self._logger.info('score_info: {}'.format(fidelity_info))
self._logger.info('weighted_score_info: {}'.format(reg_info))
if len(l1_x_s) != 0:
l1_y_s = self.synD.multi_query(l1_x_s, 0, mu, std)
else:
l1_y_s = np.empty((0, self.l1_output_dim))
l2_data_size = self._data['l2_train_loader'].size
if len(l2_x_s) != 0:
l2_y_s = self.synD.multi_query(l2_x_s, 1, mu, std)
else:
l2_y_s = np.empty((0, self.l2_output_dim))
test_nll = np.array([l1_test_nll, l2_test_nll])
test_rmse = np.array([l1_test_rmse, l2_test_rmse])
test_nrmse = np.array([l1_test_nrmse, l2_test_nrmse])
return l1_x_s, l1_y_s, l2_x_s, l2_y_s, m_batch, fidelity_info, fidelity_query, reg_info, test_nll, test_rmse, test_nrmse, l2_y_truths, l2_y_preds_mu
def init_query_points(self, m, Nq=1):
lb, ub = self.synD.get_N_bounds()
mean = self.x_scaler.mean
std = self.x_scaler.std
lb = (lb - mean)/std
ub = (ub - mean)/std
scale = (ub-lb).reshape([1,-1])
uni_noise = np.random.uniform(size=[Nq, self.input_dim])
np_Xq_init = uni_noise*scale + lb
Xq = torch.tensor(np_Xq_init, requires_grad=True, dtype=torch.float32, device=self.device_num)
return Xq, lb, ub
def opt_submod_query(self, l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov, m):
Xq, lb, ub = self.init_query_points(m)
bounds = torch.tensor(np.vstack((lb, ub))).to(self.device)
# lbfgs = LBFGS([Xq], lr=self.opt_lr, max_iter=self.opt_iter, max_eval=None)
lbfgs = LBFGS([Xq], lr=self.opt_lr, max_eval=None)
# lbfgs = torch.optim.Adam([Xq], lr=self.opt_lr)
new_model = copy.deepcopy(self.model)
new_model.train()
l1_z_mu = l1_z_mu.detach()
l1_z_cov = l1_z_cov.detach()
l2_z_mu = l2_z_mu.detach()
l2_z_cov = l2_z_cov.detach()
def closure():
lbfgs.zero_grad()
# self._logger.info('m{}'.format(m))
if m == 0:
# zs = self.model.sample_z(l1_z_mu, l1_z_cov, Xq.size(0)).detach()
zs = torch.repeat_interleave(l1_z_mu.unsqueeze(0), Xq.size(0), 0)
elif m == 1:
# zs = self.model.sample_z(l2_z_mu, l2_z_cov, Xq.size(0)).detach()
zs = torch.repeat_interleave(l2_z_mu.unsqueeze(0), Xq.size(0), 0)
# self._logger.info('zs.is_leaf{}'.format(zs.is_leaf))
Yq, _ = new_model.z_to_y(Xq, zs, level=m+1)
if m == 0:
r_mu, r_cov = new_model.xy_to_r_global(Xq, Yq, level=m+1)
# r_cov = r_cov * self.acq_weight # weighted representation
elif m == 1:
r_mu_global, r_cov_global = new_model.xy_to_r_global(Xq, Yq, level=m+1)
r_mu_local, r_cov_local = new_model.xy_to_r_local(Xq, Yq, level=m+1)
r_mu = torch.cat([r_mu_global, r_mu_local],0)
r_cov = torch.cat([r_cov_global, r_cov_local],0)
# r_cov = r_cov * self.acq_weight # weighted representation
l2_v = r_mu - l2_z_mu
l2_w_cov_inv = 1 / r_cov
l2_z_cov_new = 1 / (1 / l2_z_cov + torch.sum(l2_w_cov_inv, dim=0))
# print('l2_z_cov_new', l2_z_cov_new.min(), l2_z_cov_new.max())
l2_z_cov_new = l2_z_cov_new.clamp(min=1e-3, max=1.)
l2_z_mu_new = l2_z_mu + l2_z_cov_new * torch.sum(l2_w_cov_inv * l2_v, dim=0)
# print('l2_z_mu_new', l2_z_mu_new.min(), l2_z_mu_new.max())
l2_z_mu_new = l2_z_mu_new.clamp(min=-3.5, max=3.5)
gain = kld_gaussian_loss(l2_z_mu_new, l2_z_cov_new, l2_z_mu, l2_z_cov)
loss = -gain
# loss.backward(retain_graph=True)
loss.backward(retain_graph=True)
with torch.no_grad():
for j, (lb, ub) in enumerate(zip(*bounds)):
Xq.data[..., j].clamp_(lb, ub) # need to do this on the data not X itself
torch.nn.utils.clip_grad_norm_([Xq], self.max_grad_norm)
return loss
for epoch_num in range(self._opt_epoch_num, self._opt_epochs):
# loss = closure()
loss = lbfgs.step(closure)
# print('Xq: ', Xq)
# print('Xq.grad: ', Xq.grad)
# sys.exit()
log_every = self.opt_every_n_epochs
if (epoch_num % log_every) == log_every - 1:
message = 'Gradient optimization Epoch [{}/{}] ' \
'opt_loss: {:.4f}'.format(epoch_num, self._opt_epochs,
loss)
self._logger.info(message)
# loss = lbfgs.step(closure)
gain = -loss
# print('Xq: ', Xq)
#update z
new_model.eval()
with torch.no_grad():
if m == 0:
zs = torch.repeat_interleave(l1_z_mu.unsqueeze(0), Xq.size(0), 0)
Yq, _ = new_model.z_to_y(Xq, zs[0:1], level=m+1)
r_mu_global, r_cov_global = new_model.xy_to_r_global(Xq, Yq, level=m+1)
r_mu_local, r_cov_local = new_model.xy_to_r_local(Xq, Yq, level=m+1)
r_mu = torch.cat([r_mu_global, r_mu_local],0)
r_cov = torch.cat([r_cov_global, r_cov_local],0)
l1_v = r_mu - l1_z_mu
l1_w_cov_inv = 1 / r_cov
l1_z_cov_new = 1 / (1 / l1_z_cov + torch.sum(l1_w_cov_inv, dim=0))
l1_z_mu_new = l1_z_mu + l1_z_cov_new * torch.sum(l1_w_cov_inv * l1_v, dim=0)
l2_v = r_mu_global - l2_z_mu
l2_w_cov_inv = 1 / r_cov_global
l2_z_cov_new = 1 / (1 / l2_z_cov + torch.sum(l2_w_cov_inv, dim=0))
l2_z_mu_new = l2_z_mu + l2_z_cov_new * torch.sum(l2_w_cov_inv * l2_v, dim=0)
elif m == 1:
zs = torch.repeat_interleave(l2_z_mu.unsqueeze(0), Xq.size(0), 0)
Yq, _ = new_model.z_to_y(Xq, zs[0:1], level=m+1)
r_mu_global, r_cov_global = new_model.xy_to_r_global(Xq, Yq, level=m+1)
r_mu_local, r_cov_local = new_model.xy_to_r_local(Xq, Yq, level=m+1)
r_mu = torch.cat([r_mu_global, r_mu_local],0)
r_cov = torch.cat([r_cov_global, r_cov_local],0)
l1_v = r_mu_global - l1_z_mu
l1_w_cov_inv = 1 / r_cov_global
l1_z_cov_new = 1 / (1 / l1_z_cov + torch.sum(l1_w_cov_inv, dim=0))
l1_z_mu_new = l1_z_mu + l1_z_cov_new * torch.sum(l1_w_cov_inv * l1_v, dim=0)
l2_v = r_mu - l2_z_mu
l2_w_cov_inv = 1 / r_cov
l2_z_cov_new = 1 / (1 / l2_z_cov + torch.sum(l2_w_cov_inv, dim=0))
l2_z_mu_new = l2_z_mu + l2_z_cov_new * torch.sum(l2_w_cov_inv * l2_v, dim=0)
return gain, Xq, l1_z_mu_new, l1_z_cov_new, l2_z_mu_new, l2_z_cov_new
def random_query(self, l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov, m):
Xq, lb, ub = self.init_query_points(m, self.num_sample)
new_model = copy.deepcopy(self.model)
l1_z_mu = l1_z_mu.detach()
l1_z_cov = l1_z_cov.detach()
l2_z_mu = l2_z_mu.detach()
l2_z_cov = l2_z_cov.detach()
if m == 0:
# zs = self.model.sample_z(l1_z_mu, l1_z_cov, Xq.size(0)).detach()
zs = torch.repeat_interleave(l1_z_mu.unsqueeze(0), Xq.size(0), 0)
elif m == 1:
# zs = self.model.sample_z(l2_z_mu, l2_z_cov, Xq.size(0)).detach()
zs = torch.repeat_interleave(l2_z_mu.unsqueeze(0), Xq.size(0), 0)
Yq, _ = new_model.z_to_y(Xq, zs, level=m+1)
if m == 0:
r_mu, r_cov = new_model.xy_to_r_global(Xq, Yq, level=m+1)
r_mu = r_mu.unsqueeze(1)
r_cov = r_cov.unsqueeze(1)
# print('r_mu shape: ', r_mu.shape)
elif m == 1:
r_mu_global, r_cov_global = new_model.xy_to_r_global(Xq, Yq, level=m+1)
r_mu_local, r_cov_local = new_model.xy_to_r_local(Xq, Yq, level=m+1)
r_mu = torch.stack([r_mu_global, r_mu_local],1)
r_cov = torch.stack([r_cov_global, r_cov_local],1)
# print('r_mu shape: ', r_mu.shape)
# self._logger.info('r_cov shape: '+str(r_cov.shape))
gain_list = []
for i in range(len(r_mu)):
l2_v = r_mu[i] - l2_z_mu
l2_w_cov_inv = 1 / r_cov[i]
l2_z_cov_new = 1 / (1 / l2_z_cov + torch.sum(l2_w_cov_inv, dim=0))
l2_z_mu_new = l2_z_mu + l2_z_cov_new * torch.sum(l2_w_cov_inv * l2_v, dim=0)
gain = kld_gaussian_loss(l2_z_mu_new, l2_z_cov_new, l2_z_mu, l2_z_cov).item()
gain_list.append(gain)
gain_list = np.array(gain_list)
gain_min = np.min(gain_list)
gain_max = np.max(gain_list)
ind = np.argmax(gain_list)
gain = gain_list[ind]
#update z
Xq = Xq[ind].unsqueeze(0)
Yq, _ = new_model.z_to_y(Xq, zs[0:1], level=m+1)
if m == 0:
r_mu_global, r_cov_global = new_model.xy_to_r_global(Xq, Yq, level=m+1)
r_mu_local, r_cov_local = new_model.xy_to_r_local(Xq, Yq, level=m+1)
r_mu = torch.cat([r_mu_global, r_mu_local],0)
r_cov = torch.cat([r_cov_global, r_cov_local],0)
l1_v = r_mu - l1_z_mu
l1_w_cov_inv = 1 / r_cov
l1_z_cov_new = 1 / (1 / l1_z_cov + torch.sum(l1_w_cov_inv, dim=0))
l1_z_mu_new = l1_z_mu + l1_z_cov_new * torch.sum(l1_w_cov_inv * l1_v, dim=0)
l2_v = r_mu_global - l2_z_mu
l2_w_cov_inv = 1 / r_cov_global
l2_z_cov_new = 1 / (1 / l2_z_cov + torch.sum(l2_w_cov_inv, dim=0))
l2_z_mu_new = l2_z_mu + l2_z_cov_new * torch.sum(l2_w_cov_inv * l2_v, dim=0)
elif m == 1:
r_mu_global, r_cov_global = new_model.xy_to_r_global(Xq, Yq, level=m+1)
r_mu_local, r_cov_local = new_model.xy_to_r_local(Xq, Yq, level=m+1)
r_mu = torch.cat([r_mu_global, r_mu_local],0)
r_cov = torch.cat([r_cov_global, r_cov_local],0)
l1_v = r_mu_global - l1_z_mu
l1_w_cov_inv = 1 / r_cov_global
l1_z_cov_new = 1 / (1 / l1_z_cov + torch.sum(l1_w_cov_inv, dim=0))
l1_z_mu_new = l1_z_mu + l1_z_cov_new * torch.sum(l1_w_cov_inv * l1_v, dim=0)
l2_v = r_mu - l2_z_mu
l2_w_cov_inv = 1 / r_cov
l2_z_cov_new = 1 / (1 / l2_z_cov + torch.sum(l2_w_cov_inv, dim=0))
l2_z_mu_new = l2_z_mu + l2_z_cov_new * torch.sum(l2_w_cov_inv * l2_v, dim=0)
return gain, Xq, gain_min, gain_max, l1_z_mu_new, l1_z_cov_new, l2_z_mu_new, l2_z_cov_new
def submod_eval_next(self, l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov):
fidelity_info = []
fidelity_query = []
fidelity_costs = []
costs = self.costs #change [1,3], [1, 1]
for m in range(2): #self.M
info, xq, l1_z_mu_new, l1_z_cov_new, l2_z_mu_new, l2_z_cov_new = self.opt_submod_query(l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov, m)
fidelity_info.append(info.data.cpu().numpy())
fidelity_query.append(xq)
fidelity_costs.append(costs[m])
#
fidelity_info = np.array(fidelity_info)
fidelity_costs = np.array(fidelity_costs)
reg_info = fidelity_info / fidelity_costs
argm = np.argmax(reg_info)
argx = fidelity_query[argm]
fidelity_query = torch.stack(fidelity_query).detach().cpu().numpy()
self._logger.info('argm = '+str(argm))
self._logger.info('argx = '+str(argx.data.cpu().numpy()))
return argx, argm, fidelity_info, fidelity_query, reg_info, l1_z_mu_new, l1_z_cov_new, l2_z_mu_new, l2_z_cov_new
def random_eval_next(self, l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov):
fidelity_info = []
fidelity_query = []
fidelity_costs = []
costs = self.costs #change [1,3], [1, 1]
for m in range(2): #self.M
info, xq, gain_min, gain_max, l1_z_mu_new, l1_z_cov_new, l2_z_mu_new, l2_z_cov_new = self.random_query(l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov, m)
self._logger.info('fidelity '+ str(m) + ' min gain: '+str(gain_min))
self._logger.info('fidelity '+ str(m) + ' max gain: '+str(gain_max))
fidelity_info.append(info)
fidelity_query.append(xq)
fidelity_costs.append(costs[m])
#
fidelity_info = np.array(fidelity_info)
fidelity_costs = np.array(fidelity_costs)
reg_info = fidelity_info / fidelity_costs
argm = np.argmax(reg_info)
argx = fidelity_query[argm]
fidelity_query = torch.stack(fidelity_query).detach().cpu().numpy()
self._logger.info('argm = '+str(argm))
self._logger.info('argx = '+str(argx.data.cpu().numpy()))
return argx, argm, fidelity_info, fidelity_query, reg_info, l1_z_mu_new, l1_z_cov_new, l2_z_mu_new, l2_z_cov_new
def submod_batch_query(self, l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov, budget):
B = budget
query_costs = 0
X_batch_l1 = []
X_batch_l2 = []
m_batch = []
fidelity_info_list = []
fidelity_query_list = []
reg_info_list = []
costs = self.costs
while query_costs < B:
argX, argm, fidelity_info, fidelity_query, reg_info, l1_z_mu_new, l1_z_cov_new, l2_z_mu_new, l2_z_cov_new = self.submod_eval_next(l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov)
m_batch.append(argm)
if argm == 0:
X_batch_l1.append(argX)
if argm == 1:
X_batch_l2.append(argX)
fidelity_info_list.append(fidelity_info)
fidelity_query_list.append(fidelity_query)
reg_info_list.append(reg_info)
# self._logger.info('m_batch: {}'.format(m_batch))
current_costs = np.array([costs[m] for m in m_batch]).sum()
# self._logger.info('current_costs: {}'.format(current_costs))
query_costs = current_costs
# update l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov
l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov = l1_z_mu_new, l1_z_cov_new, l2_z_mu_new, l2_z_cov_new
m_batch = np.stack(m_batch,0)
if len(X_batch_l1) == 0:
l1_x_s = np.empty((0, self.input_dim))
else:
l1_x_s = torch.cat(X_batch_l1,0).detach().cpu().numpy()
if len(X_batch_l2) == 0:
l2_x_s = np.empty((0, self.input_dim))
else:
l2_x_s = torch.cat(X_batch_l2,0).detach().cpu().numpy()
self._logger.info('l1_x_s shape: {}, l2_x_s shape: {}, m_batch: {}'.format(l1_x_s.shape, l2_x_s.shape, m_batch))
m_batch = np.stack(m_batch)
fidelity_info = np.stack(fidelity_info_list)
fidelity_query = np.stack(fidelity_query_list)
reg_info = np.stack(reg_info_list)
return l1_x_s, l2_x_s, m_batch, fidelity_info, fidelity_query, reg_info
def random_batch_query(self, l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov, budget):
B = budget
query_costs = 0
X_batch_l1 = []
X_batch_l2 = []
m_batch = []
fidelity_info_list = []
fidelity_query_list = []
reg_info_list = []
costs = self.costs
while query_costs < B:
argX, argm, fidelity_info, fidelity_query, reg_info, l1_z_mu_new, l1_z_cov_new, l2_z_mu_new, l2_z_cov_new = self.random_eval_next(l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov)
m_batch.append(argm)
if argm == 0:
X_batch_l1.append(argX)
if argm == 1:
X_batch_l2.append(argX)
fidelity_info_list.append(fidelity_info)
fidelity_query_list.append(fidelity_query)
reg_info_list.append(reg_info)
# self._logger.info('m_batch{}'.format(m_batch))
current_costs = np.array([costs[m] for m in m_batch]).sum()
# self._logger.info('current_costs{}'.format(current_costs))
query_costs = current_costs
# update l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov
l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov = l1_z_mu_new, l1_z_cov_new, l2_z_mu_new, l2_z_cov_new
m_batch = np.stack(m_batch,0)
if len(X_batch_l1) == 0:
l1_x_s = np.empty((0, self.input_dim))
else:
l1_x_s = torch.cat(X_batch_l1,0).detach().cpu().numpy()
if len(X_batch_l2) == 0:
l2_x_s = np.empty((0, self.input_dim))
else:
l2_x_s = torch.cat(X_batch_l2,0).detach().cpu().numpy()
self._logger.info('l1_x_s shape: {}, l2_x_s shape: {}, m_batch: {}'.format(l1_x_s.shape, l2_x_s.shape, m_batch))
m_batch = np.stack(m_batch)
fidelity_info = np.stack(fidelity_info_list)
fidelity_query = np.stack(fidelity_query_list)
reg_info = np.stack(reg_info_list)
return l1_x_s, l2_x_s, m_batch, fidelity_info, fidelity_query, reg_info
def evaluate(self, dataset='val', l1_z_mu_all=None, l1_z_cov_all=None, l2_z_mu_all=None, l2_z_cov_all=None):
"""
Computes mean L1Loss
:return: mean L1Loss
"""
with torch.no_grad():
self.model = self.model.eval()
#change val_iterator
# l1_test_iterator = self._data['l1_{}_loader'.format(dataset)].get_iterator()
# l2_test_iterator = self._data['l2_{}_loader'.format(dataset)].get_iterator()
l1_x_test = self._data['l1_{}_loader'.format(dataset)].xs
l1_y_test = self._data['l1_{}_loader'.format(dataset)].ys
l2_x_test = self._data['l2_{}_loader'.format(dataset)].xs
l2_y_test = self._data['l2_{}_loader'.format(dataset)].ys
l1_y_truths = []
l2_y_truths = []
l1_y_preds_mu = []
l2_y_preds_mu = []
l1_y_preds_cov = []
l2_y_preds_cov = []
# for _, ((l1_x_test, l1_y_test), (l2_x_test, l2_y_test)) in enumerate(zip(l1_test_iterator, l2_test_iterator)): # need to be fixed
# optimizer.zero_grad()
x1_test, y1_test = self._test_l1_prepare_data(l1_x_test, l1_y_test) #train
x2_test, y2_test = self._test_l2_prepare_data(l2_x_test, l2_y_test) #train
l1_output_mu, l1_output_cov, l2_output_mu, l2_output_cov = self.model(test=True, l1_x_test=x1_test, l2_x_test=x2_test, l1_z_mu_all=l1_z_mu_all, l1_z_cov_all=l1_z_cov_all, l2_z_mu_all=l2_z_mu_all, l2_z_cov_all=l2_z_cov_all)
l1_y_truths.append(y1_test.cpu())
l2_y_truths.append(y2_test.cpu())
l1_y_preds_mu.append(l1_output_mu.cpu())
l2_y_preds_mu.append(l2_output_mu.cpu())
l1_y_preds_cov.append(l1_output_cov.cpu())
l2_y_preds_cov.append(l2_output_cov.cpu())
l1_y_preds_mu = np.concatenate(l1_y_preds_mu, axis=0)
l2_y_preds_mu = np.concatenate(l2_y_preds_mu, axis=0)
l1_y_preds_cov = np.concatenate(l1_y_preds_cov, axis=0)
l2_y_preds_cov = np.concatenate(l2_y_preds_cov, axis=0)
l1_y_truths = np.concatenate(l1_y_truths, axis=0)
l2_y_truths = np.concatenate(l2_y_truths, axis=0)
l1_nll, l1_rmse, l1_nrmse, l2_nll, l2_rmse, l2_nrmse, l2_y_truths, l2_y_preds_mu = self._test_loss(l1_y_preds_mu, l1_y_preds_cov, l1_y_truths, l2_y_preds_mu, l2_y_preds_cov, l2_y_truths)
# self._writer.add_scalar('{} loss'.format(dataset), l1_nll, l2_nll, batches_seen) #check
return l1_nll, l1_rmse, l1_nrmse, l2_nll, l2_rmse, l2_nrmse, l2_y_truths, l2_y_preds_mu
# , {'pred_mu': y_preds_mu, 'truth': y_truths}
def _train(self, base_lr,
steps, patience=50, epochs=100, lr_decay_ratio=0.1, log_every=1, save_model=1,
test_every_n_epochs=10, epsilon=1e-8, **kwargs):
# steps is used in learning rate - will see if need to use it?
min_val_loss = float('inf')
wait = 0
optimizer = torch.optim.Adam(self.model.parameters(), lr=base_lr, eps=epsilon)
lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=steps,gamma=lr_decay_ratio)
self._logger.info('Start training ...')
# this will fail if model is loaded with a changed batch_size
# self.num_batches = self._data['l2_train_loader'].num_batch
# self._logger.info("num_batches:{}".format(self.num_batches))
# batches_seen = self.num_batches * self._epoch_num
# check data size
# l1_data_size = self._data['l1_train_loader'].size
# l2_data_size = self._data['l2_train_loader'].size
for epoch_num in range(self._epoch_num, epochs):
# reshuffle the data
self._data = utils.load_dataset(**self._data_kwargs)
self.model = self.model.train()
# l1_train_iterator = self._data['l1_train_loader'].get_iterator()
# l2_train_iterator = self._data['l2_train_loader'].get_iterator()
l1_x = self._data['l1_train_loader'].xs
l1_y = self._data['l1_train_loader'].ys
l2_x = self._data['l2_train_loader'].xs
l2_y = self._data['l2_train_loader'].ys
x_ref = self._data['x_ref']
l1_y_ref = self._data['l1_y_ref']
l2_y_ref = self._data['l2_y_ref']
losses = []
l1_nll_losses = []
l2_nll_losses = []
l1_kld_losses = []
l2_kld_losses = []
global_dist_losses = []
start_time = time.time()
x_ref, l1_y_ref, l2_y_ref = self._ref_prepare_data(x_ref, l1_y_ref, l2_y_ref)
# for index, ((l1_x, l1_y), (l2_x, l2_y)) in enumerate(zip(l1_train_iterator, l2_train_iterator)): # need to be fixed
optimizer.zero_grad()
l1_x, l1_y = self._train_l1_prepare_data(l1_x, l1_y)
l2_x, l2_y = self._train_l2_prepare_data(l2_x, l2_y)
l1_output_mu, l1_output_cov, l2_output_mu, l2_output_cov, l1_truth, l2_truth, l1_z_mu_all, l1_z_cov_all, l1_z_mu_c, l1_z_cov_c, l2_z_mu_all, l2_z_cov_all, l2_z_mu_c, l2_z_cov_c, l1_r_mu_ref, l1_r_cov_ref, l2_r_mu_ref, l2_r_cov_ref = self.model(l1_x, l1_y, l2_x, l2_y, x_ref, l1_y_ref, l2_y_ref, False)
# if batches_seen == 0:
# # this is a workaround to accommodate dynamically registered parameters in DCGRUCell
# optimizer = torch.optim.Adam(self.model.parameters(), lr=base_lr, eps=epsilon)
# lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=steps,gamma=lr_decay_ratio)
l1_nll_loss, l2_nll_loss = self._compute_nll_loss(l1_output_mu, l1_output_cov, l2_output_mu, l2_output_cov, l1_truth, l2_truth)
l1_kld_loss, l2_kld_loss = self._compute_kld_loss(l1_z_mu_all, l1_z_cov_all, l1_z_mu_c, l1_z_cov_c, l2_z_mu_all, l2_z_cov_all, l2_z_mu_c, l2_z_cov_c)
global_dist_loss = self._compute_global_dist_loss(l1_r_mu_ref, l1_r_cov_ref, l2_r_mu_ref, l2_r_cov_ref)
loss = l1_nll_loss + self.fidelity_weight * l2_nll_loss + l1_kld_loss + l2_kld_loss + global_dist_loss
# loss = l1_nll_loss + l2_nll_loss + l1_kld_loss + l2_kld_loss
self._logger.debug(loss.item())
losses.append(loss.item())
l1_nll_losses.append(l1_nll_loss.item())
l2_nll_losses.append(l2_nll_loss.item())
l1_kld_losses.append(l1_kld_loss.item())
l2_kld_losses.append(l2_kld_loss.item())
global_dist_losses.append(global_dist_loss.item())
# batches_seen += 1
loss.backward()
# gradient clipping - this does it in place
torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.max_grad_norm)
optimizer.step()
lr_scheduler.step()
# _, _, val_loss, _ = self.evaluate(dataset='val', batches_seen=batches_seen)
end_time = time.time()
# self._writer.add_scalar('training loss',
# np.mean(losses),
# batches_seen)
log_every = test_every_n_epochs
if (epoch_num % log_every) == log_every - 1:
self._logger.info("epoch complete")
self._logger.info("evaluating now!")
message = 'Epoch [{}/{}] train_loss: {:.4f}, l1_nll: {:.4f}, l1_kld: {:.4f}, l2_nll: {:.4f}, l2_kld: {:.4f}, global_dist: {:.4f}, lr: {:.6f}, ' \
'{:.1f}s'.format(epoch_num, epochs,
np.mean(losses), np.mean(l1_nll_losses), np.mean(l1_kld_losses), np.mean(l2_nll_losses), np.mean(l2_kld_losses), np.mean(global_dist_losses), lr_scheduler.get_lr()[0],
(end_time - start_time))
self._logger.info(message)
if (epoch_num % test_every_n_epochs) == test_every_n_epochs - 1:
l1_test_nll, l1_test_rmse, l1_test_nrmse, l2_test_nll, l2_test_rmse, l2_test_nrmse, l2_y_truths, l2_y_preds_mu = self.evaluate(dataset='test', l1_z_mu_all=l1_z_mu_all, l1_z_cov_all=l1_z_cov_all, l2_z_mu_all=l2_z_mu_all, l2_z_cov_all=l2_z_cov_all)
message = 'Epoch [{}/{}] test_l1_nll: {:.4f}, l1_rmse: {:.4f}, l1_nrmse: {:.4f}, l2_nll: {:.4f}, l2_rmse: {:.4f}, l2_nrmse: {:.4f}, lr: {:.6f}, ' \
'{:.1f}s'.format(epoch_num, epochs,
l1_test_nll, l1_test_rmse, l1_test_nrmse, l2_test_nll, l2_test_rmse, l2_test_nrmse, lr_scheduler.get_lr()[0],
(end_time - start_time))
self._logger.info(message)
return l1_z_mu_all, l1_z_cov_all, l2_z_mu_all, l2_z_cov_all, l1_test_nll, l1_test_rmse, l1_test_nrmse, l2_test_nll, l2_test_rmse, l2_test_nrmse, l2_y_truths, l2_y_preds_mu
def _test_l1_prepare_data(self, x, y):
x = torch.from_numpy(x).float()
y = torch.from_numpy(y).float()
x = x.reshape(-1,self.input_dim)
y = y.reshape(-1,self.l1_output_dim)
return x.to(self.device), y.to(self.device)
def _test_l2_prepare_data(self, x, y):
x = torch.from_numpy(x).float()
y = torch.from_numpy(y).float()
x = x.reshape(-1,self.input_dim)
y = y.reshape(-1,self.l2_output_dim)
return x.to(self.device), y.to(self.device)
def _train_l1_prepare_data(self, x, y):
x = torch.from_numpy(x).float()
y = torch.from_numpy(y).float()
x = x.reshape(-1,self.input_dim)
y = y.reshape(-1,self.l1_output_dim)
return x.to(self.device), y.to(self.device)
def _train_l2_prepare_data(self, x, y):
x = torch.from_numpy(x).float()
y = torch.from_numpy(y).float()
x = x.reshape(-1,self.input_dim)
y = y.reshape(-1,self.l2_output_dim)
return x.to(self.device), y.to(self.device)
def _ref_prepare_data(self, x, l1_y, l2_y):
x = torch.from_numpy(x).float()
l1_y = torch.from_numpy(l1_y).float()
l2_y = torch.from_numpy(l2_y).float()
x = x.reshape(-1,self.input_dim)
l1_y = l1_y.reshape(-1,self.l1_output_dim)
l2_y = l2_y.reshape(-1,self.l2_output_dim)
return x.to(self.device), l1_y.to(self.device), l2_y.to(self.device)
def _compute_nll_loss(self, l1_output_mu, l1_output_cov, l2_output_mu, l2_output_cov, l1_truth, l2_truth):
return nll_loss(l1_output_mu, l1_output_cov, l1_truth), nll_loss(l2_output_mu, l2_output_cov, l2_truth)
def _compute_kld_loss(self, l1_z_mu_all, l1_z_cov_all, l1_z_mu_c, l1_z_cov_c, l2_z_mu_all, l2_z_cov_all, l2_z_mu_c, l2_z_cov_c):
return kld_gaussian_loss(l1_z_mu_all, l1_z_cov_all, l1_z_mu_c, l1_z_cov_c), kld_gaussian_loss(l2_z_mu_all, l2_z_cov_all, l2_z_mu_c, l2_z_cov_c)
def _compute_global_dist_loss(self, l1_r_mu_ref, l1_r_cov_ref, l2_r_mu_ref, l2_r_cov_ref):
# Calculate the means and variances of the two distributions
# print('l1_r_mu_ref, l1_r_cov_ref, l2_r_mu_ref, l2_r_cov_ref')
# print(l1_r_mu_ref.max(), l1_r_mu_ref.min(), l1_r_cov_ref.max(), l1_r_cov_ref.min(), l2_r_mu_ref.max(), l2_r_mu_ref.min(), l2_r_cov_ref.max(), l2_r_cov_ref.min())
# mu_diff = l1_r_mu_ref - l2_r_mu_ref
# print('mu_diff', mu_diff.max(), mu_diff.min())
# sigma_squared_diff = (l1_r_cov_ref ** 2) - (l2_r_cov_ref ** 2)
# print('sigma_squared_diff', sigma_squared_diff.max(), sigma_squared_diff.min())
# Calculate the Wasserstein distance
# wasserstein = (mu_diff ** 2) + sigma_squared_diff
# print('wasserstein', wasserstein.max(), wasserstein.min())
# wasserstein = torch.mean(torch.sqrt(wasserstein))
# print('wasserstein', wasserstein)
# return wasserstein
# Calculate the Jensen-Shannon divergence
# js_loss = 0.5 * (kld_gaussian_loss(l1_r_mu_ref, l1_r_cov_ref, l2_r_mu_ref, l2_r_cov_ref),
#aggregate to z:
l1_z_mu = torch.zeros(l1_r_mu_ref[0].shape).to(self.device)
l1_z_cov = torch.ones(l1_r_cov_ref[0].shape).to(self.device)
l2_z_mu = torch.zeros(l2_r_mu_ref[0].shape).to(self.device)
l2_z_cov = torch.ones(l2_r_cov_ref[0].shape).to(self.device)
l1_v = l1_r_mu_ref - l1_z_mu
l1_w_cov_inv = 1 / l1_r_cov_ref
l1_z_cov_new = 1 / (1 / l1_z_cov + torch.sum(l1_w_cov_inv, dim=0))
l1_z_mu_new = l1_z_mu + l1_z_cov_new * torch.sum(l1_w_cov_inv * l1_v, dim=0)
l2_v = l2_r_mu_ref - l2_z_mu
l2_w_cov_inv = 1 / l2_r_cov_ref
l2_z_cov_new = 1 / (1 / l2_z_cov + torch.sum(l2_w_cov_inv, dim=0))
l2_z_mu_new = l2_z_mu + l2_z_cov_new * torch.sum(l2_w_cov_inv * l2_v, dim=0)
js_loss = 0.5 * (kld_gaussian_loss(l1_z_mu_new, l1_z_cov_new, l2_z_mu_new, l2_z_cov_new) + kld_gaussian_loss(l2_z_mu_new, l2_z_cov_new, l1_z_mu_new, l1_z_cov_new))
return js_loss
def _test_loss(self, l1_y_preds_mu, l1_y_preds_cov, l1_y_truths, l2_y_preds_mu, l2_y_preds_cov, l2_y_truths):
l1_nll = nll_metric(l1_y_preds_mu, l1_y_preds_cov, l1_y_truths)
l2_nll = nll_metric(l2_y_preds_mu, l2_y_preds_cov, l2_y_truths)
l1_y_truths_scaled = self.l1_y_scaler.inverse_transform(l1_y_truths)
l1_y_preds_mu_scaled = self.l1_y_scaler.inverse_transform(l1_y_preds_mu)
l1_std = self.l1_y_scaler.std
l1_rmse = rmse_metric(l1_y_preds_mu_scaled, l1_y_truths_scaled)
l1_nrmse = rmse_metric(l1_y_preds_mu_scaled, l1_y_truths_scaled)/l1_std
l2_y_truths_scaled = self.l2_y_scaler.inverse_transform(l2_y_truths)
l2_y_preds_mu_scaled = self.l2_y_scaler.inverse_transform(l2_y_preds_mu)
l2_std = self.l2_y_scaler.std
l2_rmse = rmse_metric(l2_y_preds_mu_scaled, l2_y_truths_scaled)
l2_nrmse = rmse_metric(l2_y_preds_mu_scaled, l2_y_truths_scaled)/l2_std
return l1_nll, l1_rmse, l1_nrmse, l2_nll, l2_rmse, l2_nrmse, l2_y_truths_scaled, l2_y_preds_mu_scaled
| 38,096 | 43.453909 | 313 | py |
Multi-Fidelity-Deep-Active-Learning | Multi-Fidelity-Deep-Active-Learning-main/dmfdal_3f/train.py | from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import argparse
import yaml
from lib import utils
from model.pytorch.supervisor import Supervisor
import random
import numpy as np
import os
import pickle
def main(args):
with open(args.config_filename) as f:
supervisor_config = yaml.safe_load(f)
max_itr = supervisor_config.get('train').get('max_itr', 25) #25
seed = supervisor_config.get('train').get('seed', 1) #25
costs = supervisor_config.get('train').get('costs')
opt_rate = supervisor_config.get('train').get('opt_lr')
acq_weight = supervisor_config.get('train').get('acq_weight')
num_sample = supervisor_config.get('train').get('num_sample')
data_type = supervisor_config.get('data').get('data_type')
method = supervisor_config.get('train').get('method')
fidelity_weight = supervisor_config.get('train').get('fidelity_weight')
np.random.seed(seed)
random.seed(seed)
data = utils.load_dataset(**supervisor_config.get('data'))
supervisor = Supervisor(random_seed=seed, iteration=0, max_itr = max_itr, **supervisor_config)
# if not os.path.exists('seed%d/reward_list' % (i)): #for nRmse
# os.makedirs('seed%d/reward_list' % (i))
if not os.path.exists('results'): #for cost
os.makedirs('results')
m_batch_list = []
fidelity_info_list = []
fidelity_query_list = []
reg_info_list = []
l3_y_preds_all = []
test_nll_list = []
test_rmse_list = []
test_nrmse_list = []
for itr in range(max_itr):
supervisor._data = data
supervisor.iteration = itr
l1_x_s, l1_y_s, l2_x_s, l2_y_s, l3_x_s, l3_y_s, m_batch, fidelity_info, fidelity_query, reg_info, test_nll, test_rmse, test_nrmse, l3_y_truths, l3_y_preds_mu = supervisor.train()
selected_data = {}
selected_data['l1_x'] = l1_x_s
selected_data['l1_y'] = l1_y_s
selected_data['l2_x'] = l2_x_s
selected_data['l2_y'] = l2_y_s
selected_data['l3_x'] = l3_x_s
selected_data['l3_y'] = l3_y_s
search_config = supervisor_config.get('data').copy()
search_config['selected_data'] = selected_data
search_config['previous_data'] = data
data = utils.generate_new_trainset(**search_config)
m_batch_list.append(m_batch)
fidelity_info_list.append(fidelity_info)
fidelity_query_list.append(fidelity_query)
reg_info_list.append(reg_info)
test_nll_list.append(test_nll)
test_rmse_list.append(test_rmse)
test_nrmse_list.append(test_nrmse)
# m_batch = np.stack(m_batch_list)
# fidelity_info = np.stack(fidelity_info_list)
# fidelity_query = np.stack(fidelity_query_list).squeeze()
# reg_info = np.stack(reg_info_list)
# test_nll = np.stack(test_nll_list)
# test_rmse = np.stack(test_rmse_list)
# test_nrmse = np.stack(test_nrmse_list)
dictionary = {'fidelity': m_batch_list, 'score': fidelity_info_list, 'x': fidelity_query_list, 'weighted_score': reg_info_list, 'nll': test_nll_list, 'rmse': test_rmse_list, 'nrmse': test_nrmse_list}
with open('results/exp_'+str(data_type)+'_opt_'+str(method)+'_fweight_'+str(fidelity_weight)+'_optlr'+str(opt_rate)+'_weight'+str(acq_weight)+'_sample'+str(num_sample)+'_cost'+str(costs[-1])+'_seed'+str(seed)+'.pkl', 'wb') as f:
pickle.dump(dictionary, f)
print('l3_y_truths.shape',l3_y_truths.shape)
print('l3_y_preds_mu.shape',l3_y_preds_mu.shape)
l3_y_preds_all.append(l3_y_preds_mu)
print('l3_y_preds_all.shape',len(l3_y_preds_all))
np.save('results/exp'+str(data_type)+'_opt'+str(method)+'_sample'+str(num_sample)+'_seed'+str(seed)+'truths.npz', l3_y_truths)
np.save('results/exp'+str(data_type)+'_opt'+str(method)+'_sample'+str(num_sample)+'_seed'+str(seed)+'preds_mu.npz', l3_y_preds_all)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--config_filename', default='data/model/seed1.yaml', type=str,
help='Configuration filename for restoring the model.')
parser.add_argument('--use_cpu_only', default=False, type=bool, help='Set to true to only use cpu.')
args = parser.parse_args()
main(args)
| 4,347 | 38.171171 | 236 | py |
Multi-Fidelity-Deep-Active-Learning | Multi-Fidelity-Deep-Active-Learning-main/dmfdal_3f/model/pytorch/loss.py | import torch
import torch.nn as nn
from scipy.stats import multivariate_normal
import numpy as np
def nll_loss(pred_mu, pred_cov, y):
pred_std = torch.sqrt(pred_cov)
gaussian = torch.distributions.Normal(pred_mu, pred_std)
nll = -gaussian.log_prob(y)
nll = torch.mean(nll)
return nll
def nll_metric(pred_mu, pred_cov, y):
pred_mu = torch.from_numpy(pred_mu)
pred_cov = torch.from_numpy(pred_cov)
y = torch.from_numpy(y)
pred_std = torch.sqrt(pred_cov)
gaussian = torch.distributions.Normal(pred_mu, pred_std)
nll = -gaussian.log_prob(y)
nll = torch.mean(nll).cpu().detach().numpy()
return nll
def rmse_metric(y_pred, y_true):
loss = np.sqrt(np.mean(np.square(y_pred - y_true)))
return loss
# def nonormalized_mae_metric(y_pred, y_true):
# loss = np.abs(np.exp(y_pred) - np.exp(y_true))
# loss[loss != loss] = 0
# loss = loss.mean()
# return loss
# def mse_metric(y_pred, y_true):
# loss0 = (y_pred-y_true)**2
# loss0[loss0 != loss0] = 0
# loss = np.mean(loss0)
# return loss
def kld_gaussian_loss(z_mean_all, z_var_all, z_mean_context, z_var_context):
"""Analytical KLD between 2 Gaussians."""
mean_q, var_q, mean_p, var_p = z_mean_all, z_var_all, z_mean_context, z_var_context
std_q = torch.sqrt(var_q)
std_p = torch.sqrt(var_p)
p = torch.distributions.Normal(mean_p, std_p)
q = torch.distributions.Normal(mean_q, std_q)
# print('torch.distributions.kl_divergence(q, p)',torch.distributions.kl_divergence(q, p).shape)
return torch.mean(torch.distributions.kl_divergence(q, p))
# return torch.mean(torch.sum(torch.distributions.kl_divergence(q, p),dim=1))
| 1,747 | 33.27451 | 100 | py |
Multi-Fidelity-Deep-Active-Learning | Multi-Fidelity-Deep-Active-Learning-main/dmfdal_3f/model/pytorch/model.py | import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
# device = torch.device("cuda:5")
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
class MLP_Encoder(nn.Module):
def __init__(self,
in_dim,
out_dim,
hidden_layers=2,
hidden_dim=32):
nn.Module.__init__(self)
layers = [nn.Linear(in_dim, hidden_dim), nn.ELU()]
for _ in range(hidden_layers - 1):
# layers.append(nn.LayerNorm(hidden_dim))
layers += [nn.Linear(hidden_dim, hidden_dim), nn.ELU()]
# layers.append(nn.BatchNorm1d(hidden_dim))
layers.append(nn.Linear(hidden_dim, hidden_dim))
self.model = nn.Sequential(*layers)
self.mean_out = nn.Linear(hidden_dim, out_dim)
self.cov_out = nn.Linear(hidden_dim, out_dim)
self.cov_m = nn.Sigmoid()
def forward(self, x):
# x = torch.cat([x,adj],dim=-1)
output = self.model(x)
mean = self.mean_out(output)
# cov = self.cov_m(self.cov_out(output))
cov = 0.1+ 0.9*self.cov_m(self.cov_out(output))
return mean, cov
class MLP_Decoder(nn.Module):
def __init__(self,
in_dim,
out_dim,
hidden_layers=2,
hidden_dim=32):
nn.Module.__init__(self)
layers = [nn.Linear(in_dim, hidden_dim), nn.ELU()]
for _ in range(hidden_layers - 1):
# layers.append(nn.LayerNorm(hidden_dim))
layers += [nn.Linear(hidden_dim, hidden_dim), nn.ELU()]
# layers.append(nn.BatchNorm1d(hidden_dim))
layers.append(nn.Linear(hidden_dim, hidden_dim))
self.model = nn.Sequential(*layers)
self.mean_out = nn.Linear(hidden_dim, out_dim)
self.cov_out = nn.Linear(hidden_dim, out_dim)
self.cov_m = nn.Softplus()
def forward(self, x):
# x = torch.cat([x,adj],dim=-1)
output = self.model(x)
mean = self.mean_out(output)
cov = self.cov_m(self.cov_out(output))
# cov = torch.exp(self.cov_out(output))
return mean, cov
class Model(nn.Module):
def __init__(self, logger, **model_kwargs):
super().__init__()
self.device = torch.device(model_kwargs.get('device')) #"cuda:5"
self.hidden_layers = int(model_kwargs.get('hidden_layers',2))
self.z_dim = int(model_kwargs.get('z_dim',32))
self.input_dim = int(model_kwargs.get('input_dim', 3))
self.l1_output_dim = int(model_kwargs.get('l1_output_dim', 256))
self.l2_output_dim = int(model_kwargs.get('l2_output_dim', 1024))
self.l3_output_dim = int(model_kwargs.get('l3_output_dim', 4096))
self.hidden_dim = int(model_kwargs.get('hidden_dim', 32))
self.encoder_output_dim = self.z_dim
self.decoder_input_dim = self.z_dim + self.input_dim
self.context_percentage_low = float(model_kwargs.get('context_percentage_low', 0.2))
self.context_percentage_high = float(model_kwargs.get('context_percentage_high', 0.5))
self.l1_encoder_model_local = MLP_Encoder(self.input_dim+self.l1_output_dim, self.encoder_output_dim, self.hidden_layers, self.hidden_dim)
self.l1_encoder_model_global = MLP_Encoder(self.input_dim+self.l1_output_dim, self.encoder_output_dim, self.hidden_layers, self.hidden_dim)
self.l2_encoder_model_local = MLP_Encoder(self.input_dim+self.l2_output_dim, self.encoder_output_dim, self.hidden_layers, self.hidden_dim)
self.l2_encoder_model_global = MLP_Encoder(self.input_dim+self.l2_output_dim, self.encoder_output_dim, self.hidden_layers, self.hidden_dim)
self.l3_encoder_model_local = MLP_Encoder(self.input_dim+self.l3_output_dim, self.encoder_output_dim, self.hidden_layers, self.hidden_dim)
self.l3_encoder_model_global = MLP_Encoder(self.input_dim+self.l3_output_dim, self.encoder_output_dim, self.hidden_layers, self.hidden_dim)
self.l1_decoder_model = MLP_Decoder(self.decoder_input_dim, self.l1_output_dim, self.hidden_layers, self.hidden_dim)
self.l2_decoder_model = MLP_Decoder(self.decoder_input_dim, self.l2_output_dim, self.hidden_layers, self.hidden_dim)
self.l3_decoder_model = MLP_Decoder(self.decoder_input_dim, self.l3_output_dim, self.hidden_layers, self.hidden_dim)
self._logger = logger
def split_context_target(self, x, y, context_percentage_low, context_percentage_high):
"""Helper function to split randomly into context and target"""
context_percentage = np.random.uniform(context_percentage_low,context_percentage_high)
# if level == 1:
# node_dim = 18
# elif level == 2:
# node_dim = 85
# x = x.reshape(-1,node_dim,x.shape[-1])
# y = y.reshape(-1,node_dim,y.shape[-1])
# adj= adj.reshape(-1,node_dim,node_dim)
n_context = int(x.shape[0]*context_percentage)
ind = np.arange(x.shape[0])
mask = np.random.choice(ind, size=n_context, replace=False)
others = np.delete(ind,mask)
return x[mask], y[mask], x[others], y[others]
def sample_z(self, mean, var, n=1):
"""Reparameterisation trick."""
eps = torch.autograd.Variable(var.data.new(n,var.size(0)).normal_()).to(self.device)
std = torch.sqrt(var)
return torch.unsqueeze(mean, dim=0) + torch.unsqueeze(std, dim=0) * eps
def xy_to_r_local(self, x, y, level):
if level == 1:
r_mu, r_cov = self.l1_encoder_model_local(torch.cat([x, y],dim=-1))
elif level == 2:
r_mu, r_cov = self.l2_encoder_model_local(torch.cat([x, y],dim=-1))
elif level == 3:
r_mu, r_cov = self.l3_encoder_model_local(torch.cat([x, y],dim=-1))
return r_mu, r_cov
def xy_to_r_global(self, x, y, level):
if level == 1:
r_mu, r_cov = self.l1_encoder_model_global(torch.cat([x, y],dim=-1))
elif level == 2:
r_mu, r_cov = self.l2_encoder_model_global(torch.cat([x, y],dim=-1))
elif level == 3:
r_mu, r_cov = self.l3_encoder_model_global(torch.cat([x, y],dim=-1))
return r_mu, r_cov
def z_to_y(self, x, zs, level):
# outputs = []
if level == 1:
output = self.l1_decoder_model(torch.cat([x,zs], dim=-1))
elif level == 2:
output = self.l2_decoder_model(torch.cat([x,zs], dim=-1))
elif level == 3:
output = self.l3_decoder_model(torch.cat([x,zs], dim=-1))
return output
def ba_z_agg(self, r_mu, r_cov):
# r_mu = torch.swapaxes(r_mu,0,1)
# r_cov = torch.swapaxes(r_cov,0,1)
z_mu = torch.zeros(r_mu[0].shape).to(self.device)
z_cov = torch.ones(r_cov[0].shape).to(self.device)
# r_mu = torch.cat([r_mu_k, r_mu_g],0)
# r_cov = torch.cat([r_cov_k, r_cov_g],0)
v = r_mu - z_mu
w_cov_inv = 1 / r_cov
z_cov_new = 1 / (1 / z_cov + torch.sum(w_cov_inv, dim=0))
z_mu_new = z_mu + z_cov_new * torch.sum(w_cov_inv * v, dim=0)
return z_mu_new, z_cov_new
def forward(self, l1_x_all=None, l1_y_all=None, l2_x_all=None, l2_y_all=None, l3_x_all=None, l3_y_all=None, x_ref=None, l1_y_ref=None, l2_y_ref=None, l3_y_ref=None, test=False, l1_x_test=None, l2_x_test=None, l3_x_test=None, l1_z_mu_all=None, l1_z_cov_all=None, l2_z_mu_all=None, l2_z_cov_all=None, l3_z_mu_all=None, l3_z_cov_all=None):
if test==False:
self._logger.debug("starting point complete, starting split source and target")
#first half for context, second for target
l1_x_c,l1_y_c,l1_x_t,l1_y_t = self.split_context_target(l1_x_all,l1_y_all, self.context_percentage_low, self.context_percentage_high)
l2_x_c,l2_y_c,l2_x_t,l2_y_t = self.split_context_target(l2_x_all,l2_y_all, self.context_percentage_low, self.context_percentage_high)
l3_x_c,l3_y_c,l3_x_t,l3_y_t = self.split_context_target(l3_x_all,l3_y_all, self.context_percentage_low, self.context_percentage_high)
self._logger.debug("data split complete, starting encoder")
# compute ref distance
# print('x_ref.shape, l1_y_ref.shape', x_ref.shape, l1_y_ref.shape)
l1_r_mu_ref, l1_r_cov_ref = self.xy_to_r_global(x_ref, l1_y_ref, level=1)
l2_r_mu_ref, l2_r_cov_ref = self.xy_to_r_global(x_ref, l2_y_ref, level=2)
l3_r_mu_ref, l3_r_cov_ref = self.xy_to_r_global(x_ref, l3_y_ref, level=3)
#l1_encoder
l1_r_mu_all_k, l1_r_cov_all_k = self.xy_to_r_local(l1_x_all, l1_y_all, level=1)
l1_r_mu_c_k, l1_r_cov_c_k = self.xy_to_r_local(l1_x_c, l1_y_c, level=1)
l1_r_mu_all_g, l1_r_cov_all_g = self.xy_to_r_global(l1_x_all, l1_y_all, level=1)
l1_r_mu_c_g, l1_r_cov_c_g = self.xy_to_r_global(l1_x_c, l1_y_c, level=1)
#l2_encoder
l2_r_mu_all_k, l2_r_cov_all_k = self.xy_to_r_local(l2_x_all, l2_y_all, level=2)
l2_r_mu_c_k, l2_r_cov_c_k = self.xy_to_r_local(l2_x_c, l2_y_c, level=2)
l2_r_mu_all_g, l2_r_cov_all_g = self.xy_to_r_global(l2_x_all, l2_y_all, level=2)
l2_r_mu_c_g, l2_r_cov_c_g = self.xy_to_r_global(l2_x_c, l2_y_c, level=2)
#l3_encoder
l3_r_mu_all_k, l3_r_cov_all_k = self.xy_to_r_local(l3_x_all, l3_y_all, level=3)
l3_r_mu_c_k, l3_r_cov_c_k = self.xy_to_r_local(l3_x_c, l3_y_c, level=3)
l3_r_mu_all_g, l3_r_cov_all_g = self.xy_to_r_global(l3_x_all, l3_y_all, level=3)
l3_r_mu_c_g, l3_r_cov_c_g = self.xy_to_r_global(l3_x_c, l3_y_c, level=3)
l1_r_mu_all = torch.cat([l1_r_mu_all_k, l1_r_mu_all_g, l2_r_mu_all_g, l3_r_mu_all_g],0)
l2_r_mu_all = torch.cat([l2_r_mu_all_k, l1_r_mu_all_g, l2_r_mu_all_g, l3_r_mu_all_g],0)
l3_r_mu_all = torch.cat([l3_r_mu_all_k, l1_r_mu_all_g, l2_r_mu_all_g, l3_r_mu_all_g],0)
l1_r_cov_all = torch.cat([l1_r_cov_all_k, l1_r_cov_all_g, l2_r_cov_all_g, l3_r_cov_all_g],0)
l2_r_cov_all = torch.cat([l2_r_cov_all_k, l1_r_cov_all_g, l2_r_cov_all_g, l3_r_cov_all_g],0)
l3_r_cov_all = torch.cat([l3_r_cov_all_k, l1_r_cov_all_g, l2_r_cov_all_g, l3_r_cov_all_g],0)
l1_r_mu_c = torch.cat([l1_r_mu_c_k, l1_r_mu_c_g, l2_r_mu_all_g, l3_r_mu_all_g],0)
l2_r_mu_c = torch.cat([l2_r_mu_c_k, l1_r_mu_all_g, l2_r_mu_c_g, l3_r_mu_all_g],0)
l3_r_mu_c = torch.cat([l3_r_mu_c_k, l1_r_mu_all_g, l2_r_mu_all_g, l3_r_mu_c_g],0)
l1_r_cov_c = torch.cat([l1_r_cov_c_k, l1_r_cov_c_g, l2_r_cov_all_g, l3_r_cov_all_g],0)
l2_r_cov_c = torch.cat([l2_r_cov_c_k, l1_r_cov_all_g, l2_r_cov_c_g, l3_r_cov_all_g],0)
l3_r_cov_c = torch.cat([l3_r_cov_c_k, l1_r_cov_all_g, l2_r_cov_all_g, l3_r_cov_c_g],0)
l1_z_mu_all, l1_z_cov_all = self.ba_z_agg(l1_r_mu_all, l1_r_cov_all)
l1_z_mu_c, l1_z_cov_c = self.ba_z_agg(l1_r_mu_c, l1_r_cov_c)
l2_z_mu_all, l2_z_cov_all = self.ba_z_agg(l2_r_mu_all, l2_r_cov_all)
l2_z_mu_c, l2_z_cov_c = self.ba_z_agg(l2_r_mu_c, l2_r_cov_c)
l3_z_mu_all, l3_z_cov_all = self.ba_z_agg(l3_r_mu_all, l3_r_cov_all)
l3_z_mu_c, l3_z_cov_c = self.ba_z_agg(l3_r_mu_c, l3_r_cov_c)
#sample z
l1_zs = self.sample_z(l1_z_mu_all, l1_z_cov_all, l1_x_t.size(0))
l2_zs = self.sample_z(l2_z_mu_all, l2_z_cov_all, l2_x_t.size(0))
l3_zs = self.sample_z(l3_z_mu_all, l3_z_cov_all, l3_x_t.size(0))
#l1_decoder, l2_decoder l3_decoder
self._logger.debug("Encoder complete, starting decoder")
l1_output_mu, l1_output_cov = self.z_to_y(l1_x_t,l1_zs, level=1)
l2_output_mu, l2_output_cov = self.z_to_y(l2_x_t,l2_zs, level=2)
l3_output_mu, l3_output_cov = self.z_to_y(l3_x_t,l3_zs, level=3)
l1_truth = l1_y_t
l2_truth = l2_y_t
l3_truth = l3_y_t
self._logger.debug("Decoder complete")
# if batches_seen == 0:
# self._logger.info(
# "Total trainable parameters {}".format(count_parameters(self))
# )
return l1_output_mu, l1_output_cov, l2_output_mu, l2_output_cov, l3_output_mu, l3_output_cov, l1_truth, l2_truth, l3_truth, l1_z_mu_all, l1_z_cov_all, l1_z_mu_c, l1_z_cov_c, l2_z_mu_all, l2_z_cov_all, l2_z_mu_c, l2_z_cov_c, l3_z_mu_all, l3_z_cov_all, l3_z_mu_c, l3_z_cov_c, l1_r_mu_ref, l1_r_cov_ref, l2_r_mu_ref, l2_r_cov_ref, l3_r_mu_ref, l3_r_cov_ref
else:
l1_zs = self.sample_z(l1_z_mu_all, l1_z_cov_all, l1_x_test.size(0))
l1_output_mu, l1_output_cov = self.z_to_y(l1_x_test, l1_zs, level=1)
l2_zs = self.sample_z(l2_z_mu_all, l2_z_cov_all, l2_x_test.size(0))
l2_output_mu, l2_output_cov = self.z_to_y(l2_x_test, l2_zs, level=2)
l3_zs = self.sample_z(l3_z_mu_all, l3_z_cov_all, l3_x_test.size(0))
l3_output_mu, l3_output_cov = self.z_to_y(l3_x_test, l3_zs, level=3)
return l1_output_mu, l1_output_cov, l2_output_mu, l2_output_cov, l3_output_mu, l3_output_cov
| 13,303 | 47.202899 | 365 | py |
Multi-Fidelity-Deep-Active-Learning | Multi-Fidelity-Deep-Active-Learning-main/dmfdal_3f/model/pytorch/supervisor.py | import os
import time
import numpy as np
import torch
from torch.utils.tensorboard import SummaryWriter
from lib import utils
from model.pytorch.model import Model
from model.pytorch.loss import nll_loss
from model.pytorch.loss import nll_metric
from model.pytorch.loss import rmse_metric
# from model.pytorch.loss import nonormalized_mae_metric
from model.pytorch.loss import kld_gaussian_loss
from torch.utils.tensorboard import SummaryWriter
import model.pytorch.dataset_active as dataset
from torch.optim import LBFGS
import torch.nn as nn
import copy
import sys
import csv
# device = torch.device("cuda:1")
class Supervisor:
def __init__(self, random_seed, **kwargs):
self._kwargs = kwargs
self._data_kwargs = kwargs.get('data')
self._data_type = self._data_kwargs.get('data_type')
self.synD = dataset.Dataset(self._data_type, random_seed)
self._model_kwargs = kwargs.get('model')
self._train_kwargs = kwargs.get('train')
self.max_grad_norm = self._train_kwargs.get('max_grad_norm', 1.)
self.random_seed = random_seed
torch.manual_seed(self.random_seed)
torch.cuda.manual_seed(self.random_seed)
np.random.seed(self.random_seed)
self.costs = self._train_kwargs.get('costs', [1,3])
self.acq_weight = self._train_kwargs.get('acq_weight', 1e-2)
self.method = self._train_kwargs.get('method')
self.num_sample = int(self._train_kwargs.get('num_sample', 100))
self.fidelity_weight = self._train_kwargs.get('fidelity_weight', 1.)
# logging.
self._log_dir = self._get_log_dir(kwargs, self.random_seed, self.costs, self.acq_weight, self.num_sample, self._data_type, self.method, self.fidelity_weight)
# self._writer = SummaryWriter('runs/' + self._log_dir)
log_level = self._kwargs.get('log_level', 'INFO')
self._logger = utils.get_logger(self._log_dir, __name__, 'info.log', level=log_level)
# data set
self._data = utils.load_dataset(**self._data_kwargs)
self.x_scaler = self._data['l1_x_scaler']
self.l1_y_scaler = self._data['l1_y_scaler']
self.l2_y_scaler = self._data['l2_y_scaler']
self.l3_y_scaler = self._data['l3_y_scaler']
self.input_dim = int(self._model_kwargs.get('input_dim', 3))
self.l1_output_dim = int(self._model_kwargs.get('l1_output_dim', 256))
self.l2_output_dim = int(self._model_kwargs.get('l2_output_dim', 1024))
self.l3_output_dim = int(self._model_kwargs.get('l3_output_dim', 4096))
self.z_dim = int(self._model_kwargs.get('z_dim',32))
self.num_batches = None #int(0)
self.device_num = self._model_kwargs.get('device') #"cuda:5"
self.device = torch.device(self.device_num)
self.budget = int(self._train_kwargs.get('budget', 20))
self.opt_lr = self._train_kwargs.get('opt_lr', 1e-4)
# self.opt_iter = self._train_kwargs.get('opt_iter', 2000)
self.opt_every_n_epochs = self._train_kwargs.get('opt_every_n_epochs', 1)
# setup model
model = Model(self._logger, **self._model_kwargs)
self.model = model.cuda(self.device) if torch.cuda.is_available() else model
self._logger.info("Model created")
self._epoch_num = self._train_kwargs.get('epoch', 0)
self._opt_epoch_num = self._train_kwargs.get('opt_epoch', 0)
self._opt_epochs = self._train_kwargs.get('opt_epochs', 1000)
@staticmethod
def _get_log_dir(kwargs, random_seed, costs, acq_weight, num_sample, data_type, method, fidelity_weight):
log_dir = kwargs['train'].get('log_dir')
if log_dir is None:
learning_rate = kwargs['train'].get('base_lr')
opt_rate = kwargs['train'].get('opt_lr')
# max_diffusion_step = kwargs['model'].get('max_diffusion_step')
# num_rnn_layers = kwargs['model'].get('num_rnn_layers')
# rnn_units = kwargs['model'].get('rnn_units')
# structure = '-'.join(
# ['%d' % rnn_units for _ in range(num_rnn_layers)])
# horizon = kwargs['model'].get('horizon')
run_id = 'exp_%s_opt_%s_fweight_%g_optlr_%g_lr_%g_weight_%g_sample_%d_cost_%d_seed_%d_%s/' % (
data_type, method, fidelity_weight, opt_rate, learning_rate,
acq_weight, num_sample, costs[-1], random_seed, time.strftime('%m%d%H%M%S'))
base_dir = kwargs.get('base_dir')
log_dir = os.path.join(base_dir, run_id)
if not os.path.exists(log_dir):
os.makedirs(log_dir)
return log_dir
def train(self, **kwargs):
kwargs.update(self._train_kwargs)
l1_z_mu_all, l1_z_cov_all, l2_z_mu_all, l2_z_cov_all, l3_z_mu_all, l3_z_cov_all, l1_test_nll, l1_test_rmse, l1_test_nrmse, l2_test_nll, l2_test_rmse, l2_test_nrmse, l3_test_nll, l3_test_rmse, l3_test_nrmse, l3_y_truths_scaled, l3_y_preds_mu_scaled = self._train(**kwargs)
self._logger.info('l1_z_mu_all: {}, l1_z_cov_all: {}, l2_z_mu_all: {}, l2_z_cov_all: {}, l3_z_mu_all: {}, l3_z_cov_all: {}'.format(l1_z_mu_all, l1_z_cov_all, l2_z_mu_all, l2_z_cov_all, l3_z_mu_all, l3_z_cov_all))
if self.method == "gradient":
l1_x_s, l2_x_s, l3_x_s, m_batch, fidelity_info, fidelity_query, reg_info = self.submod_batch_query(l1_z_mu_all, l1_z_cov_all, l2_z_mu_all, l2_z_cov_all, l3_z_mu_all, l3_z_cov_all, self.budget)
elif self.method == "random":
l1_x_s, l2_x_s, l3_x_s, m_batch, fidelity_info, fidelity_query, reg_info = self.random_batch_query(l1_z_mu_all, l1_z_cov_all, l2_z_mu_all, l2_z_cov_all, l3_z_mu_all, l3_z_cov_all, self.budget)
mu = self.x_scaler.mean
std = self.x_scaler.std
fidelity_query = fidelity_query * std + mu
self._logger.info('score_info: {}'.format(fidelity_info))
self._logger.info('weighted_score_info: {}'.format(reg_info))
if len(l1_x_s) != 0:
l1_y_s = self.synD.multi_query(l1_x_s, 0, mu, std)
else:
l1_y_s = np.empty((0, self.l1_output_dim))
# l2_data_size = self._data['l2_train_loader'].size
if len(l2_x_s) != 0:
l2_y_s = self.synD.multi_query(l2_x_s, 1, mu, std)
else:
l2_y_s = np.empty((0, self.l2_output_dim))
if len(l3_x_s) != 0:
l3_y_s = self.synD.multi_query(l3_x_s, 2, mu, std)
else:
l3_y_s = np.empty((0, self.l3_output_dim))
test_nll = np.array([l1_test_nll, l2_test_nll, l3_test_nll])
test_rmse = np.array([l1_test_rmse, l2_test_rmse , l3_test_rmse])
test_nrmse = np.array([l1_test_nrmse, l2_test_nrmse, l3_test_nrmse])
return l1_x_s, l1_y_s, l2_x_s, l2_y_s, l3_x_s, l3_y_s, m_batch, fidelity_info, fidelity_query, reg_info, test_nll, test_rmse, test_nrmse, l3_y_truths_scaled, l3_y_preds_mu_scaled
def init_query_points(self, m, Nq=1):
lb, ub = self.synD.get_N_bounds()
mean = self.x_scaler.mean
std = self.x_scaler.std
lb = (lb - mean)/std
ub = (ub - mean)/std
scale = (ub-lb).reshape([1,-1])
uni_noise = np.random.uniform(size=[Nq, self.input_dim])
np_Xq_init = uni_noise*scale + lb
Xq = torch.tensor(np_Xq_init, requires_grad=True, dtype=torch.float32, device=self.device_num)
return Xq, lb, ub
def opt_submod_query(self, l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov, l3_z_mu, l3_z_cov, m):
Xq, lb, ub = self.init_query_points(m)
bounds = torch.tensor(np.vstack((lb, ub))).to(self.device)
# lbfgs = LBFGS([Xq], lr=self.opt_lr, max_iter=self.opt_iter, max_eval=None)
lbfgs = LBFGS([Xq], lr=self.opt_lr, max_eval=None)
# lbfgs = torch.optim.Adam([Xq], lr=self.opt_lr)
new_model = copy.deepcopy(self.model)
new_model.train()
l1_z_mu = l1_z_mu.detach()
l1_z_cov = l1_z_cov.detach()
l2_z_mu = l2_z_mu.detach()
l2_z_cov = l2_z_cov.detach()
l3_z_mu = l3_z_mu.detach()
l3_z_cov = l3_z_cov.detach()
def closure():
lbfgs.zero_grad()
# self._logger.info('m{}'.format(m))
if m == 0:
# zs = self.model.sample_z(l1_z_mu, l1_z_cov, Xq.size(0)).detach()
zs = torch.repeat_interleave(l1_z_mu.unsqueeze(0), Xq.size(0), 0)
elif m == 1:
# zs = self.model.sample_z(l2_z_mu, l2_z_cov, Xq.size(0)).detach()
zs = torch.repeat_interleave(l2_z_mu.unsqueeze(0), Xq.size(0), 0)
elif m == 2:
# zs = self.model.sample_z(l2_z_mu, l2_z_cov, Xq.size(0)).detach()
zs = torch.repeat_interleave(l3_z_mu.unsqueeze(0), Xq.size(0), 0)
# self._logger.info('zs.is_leaf{}'.format(zs.is_leaf))
Yq, _ = new_model.z_to_y(Xq, zs, level=m+1)
if m == 0:
r_mu, r_cov = new_model.xy_to_r_global(Xq, Yq, level=m+1)
# r_cov = r_cov * self.acq_weight # weighted representation
elif m == 1:
r_mu, r_cov = new_model.xy_to_r_global(Xq, Yq, level=m+1)
elif m == 2:
r_mu_global, r_cov_global = new_model.xy_to_r_global(Xq, Yq, level=m+1)
r_mu_local, r_cov_local = new_model.xy_to_r_local(Xq, Yq, level=m+1)
r_mu = torch.cat([r_mu_global, r_mu_local],0)
r_cov = torch.cat([r_cov_global, r_cov_local],0)
# r_cov = r_cov * self.acq_weight # weighted representation
l3_v = r_mu - l3_z_mu
l3_w_cov_inv = 1 / r_cov
l3_z_cov_new = 1 / (1 / l3_z_cov + torch.sum(l3_w_cov_inv, dim=0))
l3_z_cov_new = l3_z_cov_new.clamp(min=1e-3, max=1.)
l3_z_mu_new = l3_z_mu + l3_z_cov_new * torch.sum(l3_w_cov_inv * l3_v, dim=0)
l3_z_mu_new = l3_z_mu_new.clamp(min=-3.5, max=3.5)
gain = kld_gaussian_loss(l3_z_mu_new, l3_z_cov_new, l3_z_mu, l3_z_cov)
loss = -gain
# loss.backward(retain_graph=True)
loss.backward(retain_graph=True)
with torch.no_grad():
for j, (lb, ub) in enumerate(zip(*bounds)):
Xq.data[..., j].clamp_(lb, ub) # need to do this on the data not X itself
torch.nn.utils.clip_grad_norm_([Xq], self.max_grad_norm)
return loss
for epoch_num in range(self._opt_epoch_num, self._opt_epochs):
# loss = closure()
loss = lbfgs.step(closure)
# print('Xq: ', Xq)
# print('Xq.grad: ', Xq.grad)
# sys.exit()
log_every = self.opt_every_n_epochs
if (epoch_num % log_every) == log_every - 1:
message = 'Gradient optimization Epoch [{}/{}] ' \
'opt_loss: {:.4f}'.format(epoch_num, self._opt_epochs,
loss)
self._logger.info(message)
# loss = lbfgs.step(closure)
gain = -loss
# print('Xq: ', Xq)
#update z
new_model.eval()
with torch.no_grad():
if m == 0:
zs = torch.repeat_interleave(l1_z_mu.unsqueeze(0), Xq.size(0), 0)
Yq, _ = new_model.z_to_y(Xq, zs[0:1], level=m+1)
r_mu_global, r_cov_global = new_model.xy_to_r_global(Xq, Yq, level=m+1)
r_mu_local, r_cov_local = new_model.xy_to_r_local(Xq, Yq, level=m+1)
r_mu = torch.cat([r_mu_global, r_mu_local],0)
r_cov = torch.cat([r_cov_global, r_cov_local],0)
l1_v = r_mu - l1_z_mu
l1_w_cov_inv = 1 / r_cov
l1_z_cov_new = 1 / (1 / l1_z_cov + torch.sum(l1_w_cov_inv, dim=0))
l1_z_mu_new = l1_z_mu + l1_z_cov_new * torch.sum(l1_w_cov_inv * l1_v, dim=0)
l2_v = r_mu_global - l2_z_mu
l2_w_cov_inv = 1 / r_cov_global
l2_z_cov_new = 1 / (1 / l2_z_cov + torch.sum(l2_w_cov_inv, dim=0))
l2_z_mu_new = l2_z_mu + l2_z_cov_new * torch.sum(l2_w_cov_inv * l2_v, dim=0)
l3_v = r_mu_global - l3_z_mu
l3_w_cov_inv = 1 / r_cov_global
l3_z_cov_new = 1 / (1 / l3_z_cov + torch.sum(l3_w_cov_inv, dim=0))
l3_z_mu_new = l3_z_mu + l3_z_cov_new * torch.sum(l3_w_cov_inv * l3_v, dim=0)
elif m == 1:
zs = torch.repeat_interleave(l2_z_mu.unsqueeze(0), Xq.size(0), 0)
Yq, _ = new_model.z_to_y(Xq, zs[0:1], level=m+1)
r_mu_global, r_cov_global = new_model.xy_to_r_global(Xq, Yq, level=m+1)
r_mu_local, r_cov_local = new_model.xy_to_r_local(Xq, Yq, level=m+1)
r_mu = torch.cat([r_mu_global, r_mu_local],0)
r_cov = torch.cat([r_cov_global, r_cov_local],0)
l1_v = r_mu_global - l1_z_mu
l1_w_cov_inv = 1 / r_cov_global
l1_z_cov_new = 1 / (1 / l1_z_cov + torch.sum(l1_w_cov_inv, dim=0))
l1_z_mu_new = l1_z_mu + l1_z_cov_new * torch.sum(l1_w_cov_inv * l1_v, dim=0)
l2_v = r_mu - l2_z_mu
l2_w_cov_inv = 1 / r_cov
l2_z_cov_new = 1 / (1 / l2_z_cov + torch.sum(l2_w_cov_inv, dim=0))
l2_z_mu_new = l2_z_mu + l2_z_cov_new * torch.sum(l2_w_cov_inv * l2_v, dim=0)
l3_v = r_mu_global - l3_z_mu
l3_w_cov_inv = 1 / r_cov_global
l3_z_cov_new = 1 / (1 / l3_z_cov + torch.sum(l3_w_cov_inv, dim=0))
l3_z_mu_new = l3_z_mu + l3_z_cov_new * torch.sum(l3_w_cov_inv * l3_v, dim=0)
elif m == 2:
zs = torch.repeat_interleave(l3_z_mu.unsqueeze(0), Xq.size(0), 0)
Yq, _ = new_model.z_to_y(Xq, zs[0:1], level=m+1)
r_mu_global, r_cov_global = new_model.xy_to_r_global(Xq, Yq, level=m+1)
r_mu_local, r_cov_local = new_model.xy_to_r_local(Xq, Yq, level=m+1)
r_mu = torch.cat([r_mu_global, r_mu_local],0)
r_cov = torch.cat([r_cov_global, r_cov_local],0)
l1_v = r_mu_global - l1_z_mu
l1_w_cov_inv = 1 / r_cov_global
l1_z_cov_new = 1 / (1 / l1_z_cov + torch.sum(l1_w_cov_inv, dim=0))
l1_z_mu_new = l1_z_mu + l1_z_cov_new * torch.sum(l1_w_cov_inv * l1_v, dim=0)
l2_v = r_mu_global - l2_z_mu
l2_w_cov_inv = 1 / r_cov_global
l2_z_cov_new = 1 / (1 / l2_z_cov + torch.sum(l2_w_cov_inv, dim=0))
l2_z_mu_new = l2_z_mu + l2_z_cov_new * torch.sum(l2_w_cov_inv * l2_v, dim=0)
l3_v = r_mu - l3_z_mu
l3_w_cov_inv = 1 / r_cov
l3_z_cov_new = 1 / (1 / l3_z_cov + torch.sum(l3_w_cov_inv, dim=0))
l3_z_mu_new = l3_z_mu + l3_z_cov_new * torch.sum(l3_w_cov_inv * l3_v, dim=0)
return gain, Xq, l1_z_mu_new, l1_z_cov_new, l2_z_mu_new, l2_z_cov_new, l3_z_mu_new, l3_z_cov_new
def random_query(self, l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov, l3_z_mu, l3_z_cov, m):
Xq, lb, ub = self.init_query_points(m, self.num_sample)
new_model = copy.deepcopy(self.model)
l1_z_mu = l1_z_mu.detach()
l1_z_cov = l1_z_cov.detach()
l2_z_mu = l2_z_mu.detach()
l2_z_cov = l2_z_cov.detach()
l3_z_mu = l3_z_mu.detach()
l3_z_cov = l3_z_cov.detach()
if m == 0:
# zs = self.model.sample_z(l1_z_mu, l1_z_cov, Xq.size(0)).detach()
zs = torch.repeat_interleave(l1_z_mu.unsqueeze(0), Xq.size(0), 0)
elif m == 1:
# zs = self.model.sample_z(l2_z_mu, l2_z_cov, Xq.size(0)).detach()
zs = torch.repeat_interleave(l2_z_mu.unsqueeze(0), Xq.size(0), 0)
elif m == 2:
zs = torch.repeat_interleave(l3_z_mu.unsqueeze(0), Xq.size(0), 0)
Yq, _ = new_model.z_to_y(Xq, zs, level=m+1)
if m == 0:
r_mu, r_cov = new_model.xy_to_r_global(Xq, Yq, level=m+1)
r_mu = r_mu.unsqueeze(1)
r_cov = r_cov.unsqueeze(1)
# print('r_mu shape: ', r_mu.shape)
elif m == 1:
r_mu, r_cov = new_model.xy_to_r_global(Xq, Yq, level=m+1)
r_mu = r_mu.unsqueeze(1)
r_cov = r_cov.unsqueeze(1)
elif m == 2:
r_mu_global, r_cov_global = new_model.xy_to_r_global(Xq, Yq, level=m+1)
r_mu_local, r_cov_local = new_model.xy_to_r_local(Xq, Yq, level=m+1)
r_mu = torch.stack([r_mu_global, r_mu_local],1)
r_cov = torch.stack([r_cov_global, r_cov_local],1)
# print('r_mu shape: ', r_mu.shape)
# self._logger.info('r_cov shape: '+str(r_cov.shape))
gain_list = []
for i in range(len(r_mu)):
l3_v = r_mu[i] - l3_z_mu
l3_w_cov_inv = 1 / r_cov[i]
l3_z_cov_new = 1 / (1 / l3_z_cov + torch.sum(l3_w_cov_inv, dim=0))
l3_z_mu_new = l3_z_mu + l3_z_cov_new * torch.sum(l3_w_cov_inv * l3_v, dim=0)
gain = kld_gaussian_loss(l3_z_mu_new, l3_z_cov_new, l3_z_mu, l3_z_cov).item()
gain_list.append(gain)
gain_list = np.array(gain_list)
gain_min = np.min(gain_list)
gain_max = np.max(gain_list)
ind = np.argmax(gain_list)
gain = gain_list[ind]
#update z
Xq = Xq[ind].unsqueeze(0)
Yq, _ = new_model.z_to_y(Xq, zs[0:1], level=m+1)
if m == 0:
r_mu_global, r_cov_global = new_model.xy_to_r_global(Xq, Yq, level=m+1)
r_mu_local, r_cov_local = new_model.xy_to_r_local(Xq, Yq, level=m+1)
r_mu = torch.cat([r_mu_global, r_mu_local],0)
r_cov = torch.cat([r_cov_global, r_cov_local],0)
l1_v = r_mu - l1_z_mu
l1_w_cov_inv = 1 / r_cov
l1_z_cov_new = 1 / (1 / l1_z_cov + torch.sum(l1_w_cov_inv, dim=0))
l1_z_mu_new = l1_z_mu + l1_z_cov_new * torch.sum(l1_w_cov_inv * l1_v, dim=0)
l2_v = r_mu_global - l2_z_mu
l2_w_cov_inv = 1 / r_cov_global
l2_z_cov_new = 1 / (1 / l2_z_cov + torch.sum(l2_w_cov_inv, dim=0))
l2_z_mu_new = l2_z_mu + l2_z_cov_new * torch.sum(l2_w_cov_inv * l2_v, dim=0)
l3_v = r_mu_global - l3_z_mu
l3_w_cov_inv = 1 / r_cov_global
l3_z_cov_new = 1 / (1 / l3_z_cov + torch.sum(l3_w_cov_inv, dim=0))
l3_z_mu_new = l3_z_mu + l3_z_cov_new * torch.sum(l3_w_cov_inv * l3_v, dim=0)
elif m == 1:
r_mu_global, r_cov_global = new_model.xy_to_r_global(Xq, Yq, level=m+1)
r_mu_local, r_cov_local = new_model.xy_to_r_local(Xq, Yq, level=m+1)
r_mu = torch.cat([r_mu_global, r_mu_local],0)
r_cov = torch.cat([r_cov_global, r_cov_local],0)
l1_v = r_mu_global - l1_z_mu
l1_w_cov_inv = 1 / r_cov_global
l1_z_cov_new = 1 / (1 / l1_z_cov + torch.sum(l1_w_cov_inv, dim=0))
l1_z_mu_new = l1_z_mu + l1_z_cov_new * torch.sum(l1_w_cov_inv * l1_v, dim=0)
l2_v = r_mu - l2_z_mu
l2_w_cov_inv = 1 / r_cov
l2_z_cov_new = 1 / (1 / l2_z_cov + torch.sum(l2_w_cov_inv, dim=0))
l2_z_mu_new = l2_z_mu + l2_z_cov_new * torch.sum(l2_w_cov_inv * l2_v, dim=0)
l3_v = r_mu_global - l3_z_mu
l3_w_cov_inv = 1 / r_cov_global
l3_z_cov_new = 1 / (1 / l3_z_cov + torch.sum(l3_w_cov_inv, dim=0))
l3_z_mu_new = l3_z_mu + l3_z_cov_new * torch.sum(l3_w_cov_inv * l3_v, dim=0)
elif m == 2:
r_mu_global, r_cov_global = new_model.xy_to_r_global(Xq, Yq, level=m+1)
r_mu_local, r_cov_local = new_model.xy_to_r_local(Xq, Yq, level=m+1)
r_mu = torch.cat([r_mu_global, r_mu_local],0)
r_cov = torch.cat([r_cov_global, r_cov_local],0)
l1_v = r_mu_global - l1_z_mu
l1_w_cov_inv = 1 / r_cov_global
l1_z_cov_new = 1 / (1 / l1_z_cov + torch.sum(l1_w_cov_inv, dim=0))
l1_z_mu_new = l1_z_mu + l1_z_cov_new * torch.sum(l1_w_cov_inv * l1_v, dim=0)
l2_v = r_mu - l2_z_mu
l2_w_cov_inv = 1 / r_cov
l2_z_cov_new = 1 / (1 / l2_z_cov + torch.sum(l2_w_cov_inv, dim=0))
l2_z_mu_new = l2_z_mu + l2_z_cov_new * torch.sum(l2_w_cov_inv * l2_v, dim=0)
l3_v = r_mu - l3_z_mu
l3_w_cov_inv = 1 / r_cov
l3_z_cov_new = 1 / (1 / l3_z_cov + torch.sum(l3_w_cov_inv, dim=0))
l3_z_mu_new = l3_z_mu + l3_z_cov_new * torch.sum(l3_w_cov_inv * l3_v, dim=0)
return gain, Xq, gain_min, gain_max, l1_z_mu_new, l1_z_cov_new, l2_z_mu_new, l2_z_cov_new, l3_z_mu_new, l3_z_cov_new
def submod_eval_next(self, l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov, l3_z_mu, l3_z_cov):
fidelity_info = []
fidelity_query = []
fidelity_costs = []
costs = self.costs #change [1,3], [1, 1]
for m in range(3): #self.M
info, xq, l1_z_mu_new, l1_z_cov_new, l2_z_mu_new, l2_z_cov_new, l3_z_mu_new, l3_z_cov_new = self.opt_submod_query(l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov, l3_z_mu, l3_z_cov, m)
fidelity_info.append(info.data.cpu().numpy())
fidelity_query.append(xq)
fidelity_costs.append(costs[m])
#
fidelity_info = np.array(fidelity_info)
fidelity_costs = np.array(fidelity_costs)
reg_info = fidelity_info / fidelity_costs
argm = np.argmax(reg_info)
argx = fidelity_query[argm]
fidelity_query = torch.stack(fidelity_query).detach().cpu().numpy()
self._logger.info('argm = '+str(argm))
self._logger.info('argx = '+str(argx.data.cpu().numpy()))
return argx, argm, fidelity_info, fidelity_query, reg_info, l1_z_mu_new, l1_z_cov_new, l2_z_mu_new, l2_z_cov_new, l3_z_mu_new, l3_z_cov_new
def random_eval_next(self, l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov, l3_z_mu, l3_z_cov):
fidelity_info = []
fidelity_query = []
fidelity_costs = []
costs = self.costs #change [1,3], [1, 1]
for m in range(3): #self.M
info, xq, gain_min, gain_max, l1_z_mu_new, l1_z_cov_new, l2_z_mu_new, l2_z_cov_new, l3_z_mu_new, l3_z_cov_new = self.random_query(l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov, l3_z_mu, l3_z_cov, m)
self._logger.info('fidelity '+ str(m) + ' min gain: '+str(gain_min))
self._logger.info('fidelity '+ str(m) + ' max gain: '+str(gain_max))
fidelity_info.append(info)
fidelity_query.append(xq)
fidelity_costs.append(costs[m])
#
fidelity_info = np.array(fidelity_info)
fidelity_costs = np.array(fidelity_costs)
reg_info = fidelity_info / fidelity_costs
argm = np.argmax(reg_info)
argx = fidelity_query[argm]
fidelity_query = torch.stack(fidelity_query).detach().cpu().numpy()
self._logger.info('argm = '+str(argm))
self._logger.info('argx = '+str(argx.data.cpu().numpy()))
return argx, argm, fidelity_info, fidelity_query, reg_info, l1_z_mu_new, l1_z_cov_new, l2_z_mu_new, l2_z_cov_new, l3_z_mu_new, l3_z_cov_new
def submod_batch_query(self, l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov, l3_z_mu, l3_z_cov, budget):
B = budget
query_costs = 0
X_batch_l1 = []
X_batch_l2 = []
X_batch_l3 = []
m_batch = []
fidelity_info_list = []
fidelity_query_list = []
reg_info_list = []
costs = self.costs
while query_costs < B:
argX, argm, fidelity_info, fidelity_query, reg_info, l1_z_mu_new, l1_z_cov_new, l2_z_mu_new, l2_z_cov_new, l3_z_mu_new, l3_z_cov_new = self.submod_eval_next(l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov, l3_z_mu, l3_z_cov)
m_batch.append(argm)
if argm == 0:
X_batch_l1.append(argX)
elif argm == 1:
X_batch_l2.append(argX)
elif argm == 2:
X_batch_l3.append(argX)
fidelity_info_list.append(fidelity_info)
fidelity_query_list.append(fidelity_query)
reg_info_list.append(reg_info)
# self._logger.info('m_batch: {}'.format(m_batch))
current_costs = np.array([costs[m] for m in m_batch]).sum()
# self._logger.info('current_costs: {}'.format(current_costs))
query_costs = current_costs
# update l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov
l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov, l3_z_mu, l3_z_cov = l1_z_mu_new, l1_z_cov_new, l2_z_mu_new, l2_z_cov_new, l3_z_mu_new, l3_z_cov_new
m_batch = np.stack(m_batch,0)
if len(X_batch_l1) == 0:
l1_x_s = np.empty((0, self.input_dim))
else:
l1_x_s = torch.cat(X_batch_l1,0).detach().cpu().numpy()
if len(X_batch_l2) == 0:
l2_x_s = np.empty((0, self.input_dim))
else:
l2_x_s = torch.cat(X_batch_l2,0).detach().cpu().numpy()
if len(X_batch_l3) == 0:
l3_x_s = np.empty((0, self.input_dim))
else:
l3_x_s = torch.cat(X_batch_l3,0).detach().cpu().numpy()
self._logger.info('l1_x_s shape: {}, l2_x_s shape: {}, l3_x_s shape: {}, m_batch: {}'.format(l1_x_s.shape, l2_x_s.shape, l3_x_s.shape, m_batch))
m_batch = np.stack(m_batch)
fidelity_info = np.stack(fidelity_info_list)
fidelity_query = np.stack(fidelity_query_list)
reg_info = np.stack(reg_info_list)
return l1_x_s, l2_x_s, l3_x_s, m_batch, fidelity_info, fidelity_query, reg_info
def random_batch_query(self, l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov, l3_z_mu, l3_z_cov, budget):
B = budget
query_costs = 0
X_batch_l1 = []
X_batch_l2 = []
X_batch_l3 = []
m_batch = []
fidelity_info_list = []
fidelity_query_list = []
reg_info_list = []
costs = self.costs
while query_costs < B:
argX, argm, fidelity_info, fidelity_query, reg_info, l1_z_mu_new, l1_z_cov_new, l2_z_mu_new, l2_z_cov_new, l3_z_mu_new, l3_z_cov_new = self.random_eval_next(l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov, l3_z_mu, l3_z_cov)
m_batch.append(argm)
if argm == 0:
X_batch_l1.append(argX)
elif argm == 1:
X_batch_l2.append(argX)
elif argm == 2:
X_batch_l3.append(argX)
fidelity_info_list.append(fidelity_info)
fidelity_query_list.append(fidelity_query)
reg_info_list.append(reg_info)
# self._logger.info('m_batch{}'.format(m_batch))
current_costs = np.array([costs[m] for m in m_batch]).sum()
# self._logger.info('current_costs{}'.format(current_costs))
query_costs = current_costs
# update l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov
l1_z_mu, l1_z_cov, l2_z_mu, l2_z_cov, l3_z_mu, l3_z_cov = l1_z_mu_new, l1_z_cov_new, l2_z_mu_new, l2_z_cov_new, l3_z_mu_new, l3_z_cov_new
m_batch = np.stack(m_batch,0)
if len(X_batch_l1) == 0:
l1_x_s = np.empty((0, self.input_dim))
else:
l1_x_s = torch.cat(X_batch_l1,0).detach().cpu().numpy()
if len(X_batch_l2) == 0:
l2_x_s = np.empty((0, self.input_dim))
else:
l2_x_s = torch.cat(X_batch_l2,0).detach().cpu().numpy()
if len(X_batch_l3) == 0:
l3_x_s = np.empty((0, self.input_dim))
else:
l3_x_s = torch.cat(X_batch_l3,0).detach().cpu().numpy()
self._logger.info('l1_x_s shape: {}, l2_x_s shape: {}, l3_x_s shape: {}, m_batch: {}'.format(l1_x_s.shape, l2_x_s.shape, l3_x_s.shape, m_batch))
m_batch = np.stack(m_batch)
fidelity_info = np.stack(fidelity_info_list)
fidelity_query = np.stack(fidelity_query_list)
reg_info = np.stack(reg_info_list)
return l1_x_s, l2_x_s, l3_x_s, m_batch, fidelity_info, fidelity_query, reg_info
def evaluate(self, dataset='val', l1_z_mu_all=None, l1_z_cov_all=None, l2_z_mu_all=None, l2_z_cov_all=None, l3_z_mu_all=None, l3_z_cov_all=None):
"""
Computes mean L1Loss
:return: mean L1Loss
"""
with torch.no_grad():
self.model = self.model.eval()
#change val_iterator
# l1_test_iterator = self._data['l1_{}_loader'.format(dataset)].get_iterator()
# l2_test_iterator = self._data['l2_{}_loader'.format(dataset)].get_iterator()
l1_x_test = self._data['l1_{}_loader'.format(dataset)].xs
l1_y_test = self._data['l1_{}_loader'.format(dataset)].ys
l2_x_test = self._data['l2_{}_loader'.format(dataset)].xs
l2_y_test = self._data['l2_{}_loader'.format(dataset)].ys
l3_x_test = self._data['l3_{}_loader'.format(dataset)].xs
l3_y_test = self._data['l3_{}_loader'.format(dataset)].ys
l1_y_truths = []
l2_y_truths = []
l3_y_truths = []
l1_y_preds_mu = []
l2_y_preds_mu = []
l3_y_preds_mu = []
l1_y_preds_cov = []
l2_y_preds_cov = []
l3_y_preds_cov = []
# for _, ((l1_x_test, l1_y_test), (l2_x_test, l2_y_test)) in enumerate(zip(l1_test_iterator, l2_test_iterator)): # need to be fixed
# optimizer.zero_grad()
x1_test, y1_test = self._test_l1_prepare_data(l1_x_test, l1_y_test) #train
x2_test, y2_test = self._test_l2_prepare_data(l2_x_test, l2_y_test) #train
x3_test, y3_test = self._test_l3_prepare_data(l3_x_test, l3_y_test) #train
l1_output_mu, l1_output_cov, l2_output_mu, l2_output_cov, l3_output_mu, l3_output_cov = self.model(test=True, l1_x_test=x1_test, l2_x_test=x2_test, l3_x_test=x3_test, l1_z_mu_all=l1_z_mu_all, l1_z_cov_all=l1_z_cov_all, l2_z_mu_all=l2_z_mu_all, l2_z_cov_all=l2_z_cov_all, l3_z_mu_all=l3_z_mu_all, l3_z_cov_all=l3_z_cov_all)
l1_y_truths.append(y1_test.cpu())
l2_y_truths.append(y2_test.cpu())
l3_y_truths.append(y3_test.cpu())
l1_y_preds_mu.append(l1_output_mu.cpu())
l2_y_preds_mu.append(l2_output_mu.cpu())
l3_y_preds_mu.append(l3_output_mu.cpu())
l1_y_preds_cov.append(l1_output_cov.cpu())
l2_y_preds_cov.append(l2_output_cov.cpu())
l3_y_preds_cov.append(l3_output_cov.cpu())
l1_y_preds_mu = np.concatenate(l1_y_preds_mu, axis=0)
l2_y_preds_mu = np.concatenate(l2_y_preds_mu, axis=0)
l3_y_preds_mu = np.concatenate(l3_y_preds_mu, axis=0)
l1_y_preds_cov = np.concatenate(l1_y_preds_cov, axis=0)
l2_y_preds_cov = np.concatenate(l2_y_preds_cov, axis=0)
l3_y_preds_cov = np.concatenate(l3_y_preds_cov, axis=0)
l1_y_truths = np.concatenate(l1_y_truths, axis=0)
l2_y_truths = np.concatenate(l2_y_truths, axis=0)
l3_y_truths = np.concatenate(l3_y_truths, axis=0)
l1_nll, l1_rmse, l1_nrmse, l2_nll, l2_rmse, l2_nrmse, l3_nll, l3_rmse, l3_nrmse, l3_y_truths_scaled, l3_y_preds_mu_scaled = self._test_loss(l1_y_preds_mu, l1_y_preds_cov, l1_y_truths, l2_y_preds_mu, l2_y_preds_cov, l2_y_truths, l3_y_preds_mu, l3_y_preds_cov, l3_y_truths)
return l1_nll, l1_rmse, l1_nrmse, l2_nll, l2_rmse, l2_nrmse, l3_nll, l3_rmse, l3_nrmse, l3_y_truths_scaled, l3_y_preds_mu_scaled
# , {'pred_mu': y_preds_mu, 'truth': y_truths}
def _train(self, base_lr,
steps, patience=50, epochs=100, lr_decay_ratio=0.1, log_every=1, save_model=1,
test_every_n_epochs=10, epsilon=1e-8, **kwargs):
# steps is used in learning rate - will see if need to use it?
min_val_loss = float('inf')
wait = 0
optimizer = torch.optim.Adam(self.model.parameters(), lr=base_lr, eps=epsilon)
lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=steps,gamma=lr_decay_ratio)
self._logger.info('Start training ...')
for epoch_num in range(self._epoch_num, epochs):
# reshuffle the data
self._data = utils.load_dataset(**self._data_kwargs)
self.model = self.model.train()
l1_x = self._data['l1_train_loader'].xs
l1_y = self._data['l1_train_loader'].ys
l2_x = self._data['l2_train_loader'].xs
l2_y = self._data['l2_train_loader'].ys
l3_x = self._data['l3_train_loader'].xs
l3_y = self._data['l3_train_loader'].ys
x_ref = self._data['x_ref']
l1_y_ref = self._data['l1_y_ref']
l2_y_ref = self._data['l2_y_ref']
l3_y_ref = self._data['l3_y_ref']
losses = []
l1_nll_losses = []
l2_nll_losses = []
l3_nll_losses = []
l1_kld_losses = []
l2_kld_losses = []
l3_kld_losses = []
global_dist_losses = []
start_time = time.time()
x_ref, l1_y_ref, l2_y_ref, l3_y_ref = self._ref_prepare_data(x_ref, l1_y_ref, l2_y_ref, l3_y_ref)
# for index, ((l1_x, l1_y), (l2_x, l2_y)) in enumerate(zip(l1_train_iterator, l2_train_iterator)): # need to be fixed
optimizer.zero_grad()
l1_x, l1_y = self._train_l1_prepare_data(l1_x, l1_y)
l2_x, l2_y = self._train_l2_prepare_data(l2_x, l2_y)
l3_x, l3_y = self._train_l3_prepare_data(l3_x, l3_y)
l1_output_mu, l1_output_cov, l2_output_mu, l2_output_cov, l3_output_mu, l3_output_cov, l1_truth, l2_truth, l3_truth, l1_z_mu_all, l1_z_cov_all, l1_z_mu_c, l1_z_cov_c, l2_z_mu_all, l2_z_cov_all, l2_z_mu_c, l2_z_cov_c, l3_z_mu_all, l3_z_cov_all, l3_z_mu_c, l3_z_cov_c, l1_r_mu_ref, l1_r_cov_ref, l2_r_mu_ref, l2_r_cov_ref, l3_r_mu_ref, l3_r_cov_ref = self.model(l1_x, l1_y, l2_x, l2_y, l3_x, l3_y, x_ref, l1_y_ref, l2_y_ref, l3_y_ref, False)
l1_nll_loss, l2_nll_loss, l3_nll_loss = self._compute_nll_loss(l1_output_mu, l1_output_cov, l2_output_mu, l2_output_cov, l3_output_mu, l3_output_cov, l1_truth, l2_truth, l3_truth)
l1_kld_loss, l2_kld_loss, l3_kld_loss = self._compute_kld_loss(l1_z_mu_all, l1_z_cov_all, l1_z_mu_c, l1_z_cov_c, l2_z_mu_all, l2_z_cov_all, l2_z_mu_c, l2_z_cov_c, l3_z_mu_all, l3_z_cov_all, l3_z_mu_c, l3_z_cov_c)
global_dist_loss = self._compute_global_dist_loss(l1_r_mu_ref, l1_r_cov_ref, l2_r_mu_ref, l2_r_cov_ref, l3_r_mu_ref, l3_r_cov_ref)
loss = l1_nll_loss + l2_nll_loss + self.fidelity_weight * l3_nll_loss + l1_kld_loss + l2_kld_loss + l3_kld_loss + global_dist_loss
# loss = l1_nll_loss + l2_nll_loss + l1_kld_loss + l2_kld_loss
self._logger.debug(loss.item())
losses.append(loss.item())
l1_nll_losses.append(l1_nll_loss.item())
l2_nll_losses.append(l2_nll_loss.item())
l3_nll_losses.append(l3_nll_loss.item())
l1_kld_losses.append(l1_kld_loss.item())
l2_kld_losses.append(l2_kld_loss.item())
l3_kld_losses.append(l3_kld_loss.item())
global_dist_losses.append(global_dist_loss.item())
# batches_seen += 1
loss.backward()
# gradient clipping - this does it in place
torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.max_grad_norm)
optimizer.step()
lr_scheduler.step()
# _, _, val_loss, _ = self.evaluate(dataset='val', batches_seen=batches_seen)
end_time = time.time()
# self._writer.add_scalar('training loss',
# np.mean(losses),
# batches_seen)
log_every = test_every_n_epochs
if (epoch_num % log_every) == log_every - 1:
self._logger.info("epoch complete")
self._logger.info("evaluating now!")
message = 'Epoch [{}/{}] train_loss: {:.4f}, l1_nll: {:.4f}, l1_kld: {:.4f}, l2_nll: {:.4f}, l2_kld: {:.4f}, l3_nll: {:.4f}, l3_kld: {:.4f}, global_dist: {:.4f}, lr: {:.6f}, ' \
'{:.1f}s'.format(epoch_num, epochs,
np.mean(losses), np.mean(l1_nll_losses), np.mean(l1_kld_losses), np.mean(l2_nll_losses), np.mean(l2_kld_losses), np.mean(l3_nll_losses), np.mean(l3_kld_losses), np.mean(global_dist_losses), lr_scheduler.get_lr()[0],
(end_time - start_time))
self._logger.info(message)
if (epoch_num % test_every_n_epochs) == test_every_n_epochs - 1:
l1_test_nll, l1_test_rmse, l1_test_nrmse, l2_test_nll, l2_test_rmse, l2_test_nrmse, l3_test_nll, l3_test_rmse, l3_test_nrmse, l3_y_truths_scaled, l3_y_preds_mu_scaled = self.evaluate(dataset='test', l1_z_mu_all=l1_z_mu_all, l1_z_cov_all=l1_z_cov_all, l2_z_mu_all=l2_z_mu_all, l2_z_cov_all=l2_z_cov_all, l3_z_mu_all=l3_z_mu_all, l3_z_cov_all=l3_z_cov_all)
message = 'Epoch [{}/{}] test_l1_nll: {:.4f}, l1_rmse: {:.4f}, l1_nrmse: {:.4f}, l2_nll: {:.4f}, l2_rmse: {:.4f}, l2_nrmse: {:.4f}, l3_nll: {:.4f}, l3_rmse: {:.4f}, l3_nrmse: {:.4f}, lr: {:.6f}, ' \
'{:.1f}s'.format(epoch_num, epochs,
l1_test_nll, l1_test_rmse, l1_test_nrmse, l2_test_nll, l2_test_rmse, l2_test_nrmse, l3_test_nll, l3_test_rmse, l3_test_nrmse, lr_scheduler.get_lr()[0],
(end_time - start_time))
self._logger.info(message)
return l1_z_mu_all, l1_z_cov_all, l2_z_mu_all, l2_z_cov_all, l3_z_mu_all, l3_z_cov_all, l1_test_nll, l1_test_rmse, l1_test_nrmse, l2_test_nll, l2_test_rmse, l2_test_nrmse, l3_test_nll, l3_test_rmse, l3_test_nrmse, l3_y_truths_scaled, l3_y_preds_mu_scaled
def _test_l1_prepare_data(self, x, y):
x = torch.from_numpy(x).float()
y = torch.from_numpy(y).float()
x = x.reshape(-1,self.input_dim)
y = y.reshape(-1,self.l1_output_dim)
return x.to(self.device), y.to(self.device)
def _test_l2_prepare_data(self, x, y):
x = torch.from_numpy(x).float()
y = torch.from_numpy(y).float()
x = x.reshape(-1,self.input_dim)
y = y.reshape(-1,self.l2_output_dim)
return x.to(self.device), y.to(self.device)
def _test_l3_prepare_data(self, x, y):
x = torch.from_numpy(x).float()
y = torch.from_numpy(y).float()
x = x.reshape(-1,self.input_dim)
y = y.reshape(-1,self.l3_output_dim)
return x.to(self.device), y.to(self.device)
def _train_l1_prepare_data(self, x, y):
x = torch.from_numpy(x).float()
y = torch.from_numpy(y).float()
x = x.reshape(-1,self.input_dim)
y = y.reshape(-1,self.l1_output_dim)
return x.to(self.device), y.to(self.device)
def _train_l2_prepare_data(self, x, y):
x = torch.from_numpy(x).float()
y = torch.from_numpy(y).float()
x = x.reshape(-1,self.input_dim)
y = y.reshape(-1,self.l2_output_dim)
return x.to(self.device), y.to(self.device)
def _train_l3_prepare_data(self, x, y):
x = torch.from_numpy(x).float()
y = torch.from_numpy(y).float()
x = x.reshape(-1,self.input_dim)
y = y.reshape(-1,self.l3_output_dim)
return x.to(self.device), y.to(self.device)
def _ref_prepare_data(self, x, l1_y, l2_y, l3_y):
x = torch.from_numpy(x).float()
l1_y = torch.from_numpy(l1_y).float()
l2_y = torch.from_numpy(l2_y).float()
l3_y = torch.from_numpy(l3_y).float()
x = x.reshape(-1,self.input_dim)
l1_y = l1_y.reshape(-1,self.l1_output_dim)
l2_y = l2_y.reshape(-1,self.l2_output_dim)
l3_y = l3_y.reshape(-1,self.l3_output_dim)
return x.to(self.device), l1_y.to(self.device), l2_y.to(self.device), l3_y.to(self.device)
def _compute_nll_loss(self, l1_output_mu, l1_output_cov, l2_output_mu, l2_output_cov, l3_output_mu, l3_output_cov, l1_truth, l2_truth, l3_truth):
return nll_loss(l1_output_mu, l1_output_cov, l1_truth), nll_loss(l2_output_mu, l2_output_cov, l2_truth), nll_loss(l3_output_mu, l3_output_cov, l3_truth)
def _compute_kld_loss(self, l1_z_mu_all, l1_z_cov_all, l1_z_mu_c, l1_z_cov_c, l2_z_mu_all, l2_z_cov_all, l2_z_mu_c, l2_z_cov_c, l3_z_mu_all, l3_z_cov_all, l3_z_mu_c, l3_z_cov_c):
return kld_gaussian_loss(l1_z_mu_all, l1_z_cov_all, l1_z_mu_c, l1_z_cov_c), kld_gaussian_loss(l2_z_mu_all, l2_z_cov_all, l2_z_mu_c, l2_z_cov_c), kld_gaussian_loss(l3_z_mu_all, l3_z_cov_all, l3_z_mu_c, l3_z_cov_c)
def _compute_global_dist_loss(self, l1_r_mu_ref, l1_r_cov_ref, l2_r_mu_ref, l2_r_cov_ref, l3_r_mu_ref, l3_r_cov_ref):
l1_z_mu = torch.zeros(l1_r_mu_ref[0].shape).to(self.device)
l1_z_cov = torch.ones(l1_r_cov_ref[0].shape).to(self.device)
l2_z_mu = torch.zeros(l2_r_mu_ref[0].shape).to(self.device)
l2_z_cov = torch.ones(l2_r_cov_ref[0].shape).to(self.device)
l3_z_mu = torch.zeros(l3_r_mu_ref[0].shape).to(self.device)
l3_z_cov = torch.ones(l3_r_cov_ref[0].shape).to(self.device)
l1_v = l1_r_mu_ref - l1_z_mu
l1_w_cov_inv = 1 / l1_r_cov_ref
l1_z_cov_new = 1 / (1 / l1_z_cov + torch.sum(l1_w_cov_inv, dim=0))
l1_z_mu_new = l1_z_mu + l1_z_cov_new * torch.sum(l1_w_cov_inv * l1_v, dim=0)
l2_v = l2_r_mu_ref - l2_z_mu
l2_w_cov_inv = 1 / l2_r_cov_ref
l2_z_cov_new = 1 / (1 / l2_z_cov + torch.sum(l2_w_cov_inv, dim=0))
l2_z_mu_new = l2_z_mu + l2_z_cov_new * torch.sum(l2_w_cov_inv * l2_v, dim=0)
l3_v = l3_r_mu_ref - l3_z_mu
l3_w_cov_inv = 1 / l3_r_cov_ref
l3_z_cov_new = 1 / (1 / l3_z_cov + torch.sum(l3_w_cov_inv, dim=0))
l3_z_mu_new = l3_z_mu + l3_z_cov_new * torch.sum(l3_w_cov_inv * l3_v, dim=0)
js_loss_12 = 0.5 * (kld_gaussian_loss(l1_z_mu_new, l1_z_cov_new, l2_z_mu_new, l2_z_cov_new) + kld_gaussian_loss(l2_z_mu_new, l2_z_cov_new, l1_z_mu_new, l1_z_cov_new))
js_loss_13 = 0.5 * (kld_gaussian_loss(l1_z_mu_new, l1_z_cov_new, l3_z_mu_new, l3_z_cov_new) + kld_gaussian_loss(l3_z_mu_new, l3_z_cov_new, l1_z_mu_new, l1_z_cov_new))
js_loss_23 = 0.5 * (kld_gaussian_loss(l2_z_mu_new, l2_z_cov_new, l3_z_mu_new, l3_z_cov_new) + kld_gaussian_loss(l3_z_mu_new, l3_z_cov_new, l2_z_mu_new, l2_z_cov_new))
js_loss = js_loss_12 + js_loss_13 + js_loss_23
return js_loss
def _test_loss(self, l1_y_preds_mu, l1_y_preds_cov, l1_y_truths, l2_y_preds_mu, l2_y_preds_cov, l2_y_truths, l3_y_preds_mu, l3_y_preds_cov, l3_y_truths):
l1_nll = nll_metric(l1_y_preds_mu, l1_y_preds_cov, l1_y_truths)
l2_nll = nll_metric(l2_y_preds_mu, l2_y_preds_cov, l2_y_truths)
l3_nll = nll_metric(l3_y_preds_mu, l3_y_preds_cov, l3_y_truths)
l1_y_truths_scaled = self.l1_y_scaler.inverse_transform(l1_y_truths)
l1_y_preds_mu_scaled = self.l1_y_scaler.inverse_transform(l1_y_preds_mu)
l1_std = self.l1_y_scaler.std
l1_rmse = rmse_metric(l1_y_preds_mu_scaled, l1_y_truths_scaled)
l1_nrmse = rmse_metric(l1_y_preds_mu_scaled, l1_y_truths_scaled)/l1_std
l2_y_truths_scaled = self.l2_y_scaler.inverse_transform(l2_y_truths)
l2_y_preds_mu_scaled = self.l2_y_scaler.inverse_transform(l2_y_preds_mu)
l2_std = self.l2_y_scaler.std
l2_rmse = rmse_metric(l2_y_preds_mu_scaled, l2_y_truths_scaled)
l2_nrmse = rmse_metric(l2_y_preds_mu_scaled, l2_y_truths_scaled)/l2_std
l3_y_truths_scaled = self.l3_y_scaler.inverse_transform(l3_y_truths)
l3_y_preds_mu_scaled = self.l3_y_scaler.inverse_transform(l3_y_preds_mu)
l3_std = self.l3_y_scaler.std
l3_rmse = rmse_metric(l3_y_preds_mu_scaled, l3_y_truths_scaled)
l3_nrmse = rmse_metric(l3_y_preds_mu_scaled, l3_y_truths_scaled)/l3_std
return l1_nll, l1_rmse, l1_nrmse, l2_nll, l2_rmse, l2_nrmse, l3_nll, l3_rmse, l3_nrmse, l3_y_truths_scaled, l3_y_preds_mu_scaled
| 44,457 | 45.748686 | 451 | py |
RCIG | RCIG-master/tinyimagenet.py | """
TF: https://github.com/ksachdeva/tiny-imagenet-tfds/blob/master/tiny_imagenet/_imagenet.py
PyTorch: https://gist.github.com/lromor/bcfc69dcf31b2f3244358aea10b7a11b
"""
import os
import tensorflow as tf
import tensorflow_datasets.public_api as tfds
_URL = "http://cs231n.stanford.edu/tiny-imagenet-200.zip"
_EXTRACTED_FOLDER_NAME = "tiny-imagenet-200"
SUPPORTED_IMAGE_FORMAT = (".jpg", ".jpeg", ".png")
def _list_folders(root_dir):
return [
f for f in tf.io.gfile.listdir(root_dir)
if tf.io.gfile.isdir(os.path.join(root_dir, f))
]
def _list_imgs(root_dir):
return [
os.path.join(root_dir, f)
for f in tf.io.gfile.listdir(root_dir)
if any(f.lower().endswith(ext) for ext in SUPPORTED_IMAGE_FORMAT)
]
class_names = ['Egyptian cat', 'reel', 'volleyball', 'rocking chair', 'lemon', 'bullfrog', 'basketball', 'cliff',
'espresso', 'plunger', 'parking meter', 'German shepherd', 'dining table', 'monarch', 'brown bear',
'school bus', 'pizza', 'guinea pig', 'umbrella', 'organ', 'oboe', 'maypole', 'goldfish', 'potpie',
'hourglass', 'seashore', 'computer keyboard', 'Arabian camel', 'ice cream', 'nail', 'space heater',
'cardigan', 'baboon', 'snail', 'coral reef', 'albatross', 'spider web', 'sea cucumber', 'backpack',
'Labrador retriever', 'pretzel', 'king penguin', 'sulphur butterfly', 'tarantula', 'lesser panda',
'pop bottle', 'banana', 'sock', 'cockroach', 'projectile', 'beer bottle', 'mantis', 'freight car',
'guacamole', 'remote control', 'European fire salamander', 'lakeside', 'chimpanzee', 'pay-phone',
'fur coat', 'alp', 'lampshade', 'torch', 'abacus', 'moving van', 'barrel', 'tabby', 'goose', 'koala',
'bullet train', 'CD player', 'teapot', 'birdhouse', 'gazelle', 'academic gown', 'tractor', 'ladybug',
'miniskirt', 'golden retriever', 'triumphal arch', 'cannon', 'neck brace', 'sombrero', 'gasmask',
'candle', 'desk', 'frying pan', 'bee', 'dam', 'spiny lobster', 'police van', 'iPod', 'punching bag',
'beacon', 'jellyfish', 'wok', "potter's wheel", 'sandal', 'pill bottle', 'butcher shop', 'slug', 'hog',
'cougar', 'crane', 'vestment', 'dragonfly', 'cash machine', 'mushroom', 'jinrikisha', 'water tower',
'chest', 'snorkel', 'sunglasses', 'fly', 'limousine', 'black stork', 'dugong', 'sports car', 'water jug',
'suspension bridge', 'ox', 'ice lolly', 'turnstile', 'Christmas stocking', 'broom', 'scorpion',
'wooden spoon', 'picket fence', 'rugby ball', 'sewing machine', 'steel arch bridge', 'Persian cat',
'refrigerator', 'barn', 'apron', 'Yorkshire terrier', 'swimming trunks', 'stopwatch', 'lawn mower',
'thatch', 'fountain', 'black widow', 'bikini', 'plate', 'teddy', 'barbershop', 'confectionery',
'beach wagon', 'scoreboard', 'orange', 'flagpole', 'American lobster', 'trolleybus', 'drumstick',
'dumbbell', 'brass', 'bow tie', 'convertible', 'bighorn', 'orangutan', 'American alligator', 'centipede',
'syringe', 'go-kart', 'brain coral', 'sea slug', 'cliff dwelling', 'mashed potato', 'viaduct',
'military uniform', 'pomegranate', 'chain', 'kimono', 'comic book', 'trilobite', 'bison', 'pole',
'boa constrictor', 'poncho', 'bathtub', 'grasshopper', 'walking stick', 'Chihuahua', 'tailed frog',
'lion', 'altar', 'obelisk', 'beaker', 'bell pepper', 'bannister', 'bucket', 'magnetic compass',
'meat loaf', 'gondola', 'standard poodle', 'acorn', 'lifeboat', 'binoculars', 'cauliflower',
'African elephant']
# Use V2 to avoid name collision with tfds
class TinyImagenetV2(tfds.core.GeneratorBasedBuilder):
""" tiny-imagenet dataset """
VERSION = tfds.core.Version('1.0.0')
def _info(self):
return tfds.core.DatasetInfo(
builder=self,
description=("""Tiny ImageNet Challenge is a similar challenge as ImageNet with a smaller dataset but
less image classes. It contains 200 image classes, a training
dataset of 100, 000 images, a validation dataset of 10, 000
images, and a test dataset of 10, 000 images. All images are
of size 64×64."""),
features=tfds.features.FeaturesDict({
"image": tfds.features.Image(shape=(64, 64, 3), encoding_format="jpeg"),
"id": tfds.features.Text(),
"label": tfds.features.ClassLabel(names=class_names),
}),
supervised_keys=("image", "label"),
homepage="https://tiny-imagenet.herokuapp.com/",
citation=r"""@article{tiny-imagenet,
author = {Li,Fei-Fei}, {Karpathy,Andrej} and {Johnson,Justin}"}""",
)
def _process_train_ds(self, ds_folder, identities):
path_to_ds = os.path.join(ds_folder, 'train')
names = _list_folders(path_to_ds)
label_images = {}
for n in names:
images_dir = os.path.join(path_to_ds, n, 'images')
total_images = _list_imgs(images_dir)
label_images[n] = {
'images': total_images,
'id': identities.index(n)
}
return label_images
def _process_test_ds(self, ds_folder, identities):
path_to_ds = os.path.join(ds_folder, 'val')
# read the val_annotations.txt file
with tf.io.gfile.GFile(os.path.join(path_to_ds, 'val_annotations.txt')) as f:
data_raw = f.read()
lines = data_raw.split("\n")
label_images = {}
for line in lines:
if line == '':
continue
row_values = line.strip().split()
label_name = row_values[1]
if not label_name in label_images.keys():
label_images[label_name] = {
'images': [],
'id': identities.index(label_name)
}
label_images[label_name]['images'].append(
os.path.join(path_to_ds, 'images', row_values[0]))
return label_images
def _split_generators(self, dl_manager):
extracted_path = dl_manager.extract(dl_manager.download(_URL))
ds_folder = os.path.join(extracted_path, _EXTRACTED_FOLDER_NAME)
with tf.io.gfile.GFile(os.path.join(ds_folder, 'wnids.txt')) as f:
data_raw = f.read()
lines = data_raw.split("\n")
train_label_images = self._process_train_ds(ds_folder, lines)
test_label_images = self._process_test_ds(ds_folder, lines)
return [
tfds.core.SplitGenerator(
name=tfds.Split.TRAIN,
gen_kwargs=dict(label_images=train_label_images, )),
tfds.core.SplitGenerator(
name=tfds.Split.TEST,
gen_kwargs=dict(label_images=test_label_images, )),
]
def _generate_examples(self, label_images):
for label, image_info in label_images.items():
for image_path in image_info['images']:
key = "%s/%s" % (label, os.path.basename(image_path))
yield key, {
"image": image_path,
"id": label,
"label": image_info['id'],
}
| 7,513 | 46.859873 | 120 | py |
RCIG | RCIG-master/dataloader.py | #A lot of this code is reused from https://github.com/yongchao97/FRePo
from absl import logging
import os
import numpy as np
import jax.numpy as jnp
import tensorflow as tf
import tensorflow_datasets as tfds
from imagewoof import ImagewoofV2
from imagenette import ImagenetteV2
from tinyimagenet import TinyImagenetV2
from ops import compute_zca_mean_cov_ds, get_whitening_transform, get_preprocess_op_np, load_data, process2tfrecord
# Precomputed mean and std
data_stats = {
'mnist': ([0.1307], [0.3081]),
'fashion_mnist': ([0.2861], [0.3530]),
'cifar10': ([0.4914, 0.4822, 0.4465], [0.2470, 0.2435, 0.2616]),
'cifar100': ([0.5071, 0.4866, 0.4409], [0.2673, 0.2564, 0.2762]),
'tiny_imagenet': ([0.4759, 0.4481, 0.3926], [0.2763, 0.2687, 0.2813]),
'imagenette': ([0.4626, 0.4588, 0.4251], [0.2790, 0.2745, 0.2973]),
'imagewoof': ([0.4917, 0.4613, 0.3931], [0.2513, 0.2442, 0.2530]),
'imagenet_resized/32x32': ([0.4811, 0.4575, 0.4079], [0.2604, 0.2532, 0.2682]),
'imagenet_resized/64x64': ([0.4815, 0.4578, 0.4082], [0.2686, 0.2613, 0.2758]),
'caltech_birds2011': ([0.4810, 0.4964, 0.4245], [0.2129, 0.2084, 0.2468])
}
def get_ds_builder(dataset_name, data_dir):
if dataset_name == 'imagewoof':
ds_builder = ImagewoofV2(data_dir=data_dir)
elif dataset_name == 'imagenette':
ds_builder = ImagenetteV2(data_dir=data_dir)
elif dataset_name == 'tiny_imagenet':
ds_builder = TinyImagenetV2(data_dir=data_dir)
else:
ds_builder = tfds.builder(dataset_name, data_dir=data_dir)
ds_builder.download_and_prepare()
return ds_builder
def configure_dataloader(ds, batch_size, x_transform=None, y_transform=None, train=False, shuffle=False, seed=0):
if y_transform is None:
y_transform = lambda x: x
else:
y_transform = y_transform
ds = ds.cache()
if train:
ds = ds.repeat()
if shuffle:
ds = ds.shuffle(16 * batch_size, seed=seed)
if x_transform:
ds = ds.map(lambda x, y: (x_transform(x), y_transform(y)), tf.data.AUTOTUNE)
else:
ds = ds.map(lambda x, y: (x, y_transform(y)), tf.data.AUTOTUNE)
ds = ds.batch(batch_size=batch_size)
ds = ds.prefetch(buffer_size=tf.data.AUTOTUNE)
return ds
def get_dataset(config, return_raw=False):
dataset_name = config.name
data_path = config.data_path
zca_path = config.zca_path
zca_reg = config.zca_reg
if dataset_name in ['imagenet_resized/64x64', 'imagenette', 'imagewoof']:
split = ['train', 'validation']
else:
split = ['train', 'test']
if dataset_name in ['mnist', 'fashion_mnist']:
preprocess_type = 'standard'
else:
preprocess_type = 'normalize_zca'
if dataset_name in ['imagenette', 'imagewoof']:
use_checkboard = True
use_mean_block = True
block_size = 64
resolution = 128
elif dataset_name in ['imagenet_resized/64x64', 'tiny_imagenet']:
use_checkboard = False
use_mean_block = False
block_size = None
resolution = 64
else:
use_checkboard = False
use_mean_block = False
block_size = None
resolution = 32
ds_builder = get_ds_builder(dataset_name, data_path)
img_shape = ds_builder.info.features['image'].shape
num_train, num_test = ds_builder.info.splits[split[0]].num_examples, ds_builder.info.splits[split[1]].num_examples
num_classes, class_names = ds_builder.info.features['label'].num_classes, ds_builder.info.features['label'].names
mean, std = data_stats[dataset_name]
mean, std = np.array(mean), np.array(std)
if preprocess_type == 'standard':
zca_mean, whitening_transform, rev_whitening_transform = None, None, None
elif preprocess_type == 'normalize_zca':
if not os.path.exists(zca_path):
os.makedirs(zca_path)
if '/' in dataset_name:
name = dataset_name.split('/')[0]
if not os.path.exists('{}/{}'.format(zca_path, name)):
os.makedirs('{}/{}'.format(zca_path, name))
if block_size is None:
path = os.path.join(zca_path, '{}_{}.npz'.format(dataset_name, preprocess_type))
else:
if use_checkboard:
path = os.path.join(zca_path,
'{}_{}_res{}_block{}_mean{}_cb.npz'.format(dataset_name, preprocess_type,
resolution, block_size, use_mean_block))
else:
path = os.path.join(zca_path,
'{}_{}_res{}_block{}_mean{}.npz'.format(dataset_name, preprocess_type,
resolution, block_size, use_mean_block))
if not os.path.exists(path):
logging.info('Compute block zca with block_size {} and save to {}!'.format(block_size, path))
ds_train = ds_builder.as_dataset(split='train', as_supervised=True)
zca_mean, cov = compute_zca_mean_cov_ds(ds_train, img_shape, mean=mean, std=std, resolution=resolution,
block_size=block_size, batch_size=5000,
use_checkboard=use_checkboard)
whitening_transform, rev_whitening_transform = get_whitening_transform(cov, num_train, zca_reg=zca_reg,
use_mean_block=use_mean_block)
np.savez(path, whitening_transform=whitening_transform, rev_whitening_transform=rev_whitening_transform,
zca_mean=zca_mean)
else:
logging.info('Load from {}!'.format(path))
npzfile = np.load(path)
whitening_transform, rev_whitening_transform, zca_mean = npzfile['whitening_transform'], npzfile[
'rev_whitening_transform'], npzfile['zca_mean']
else:
raise ValueError('Unknown PreprocessType {}!'.format(preprocess_type))
preprocess_op, rev_preprocess_op = get_preprocess_op_np(mean=mean, std=std, zca_mean=zca_mean,
whitening_transform=whitening_transform,
rev_whitening_transform=rev_whitening_transform,
block_size=block_size, use_mean_block=use_mean_block,
use_checkboard=use_checkboard)
ds_train, ds_test = ds_builder.as_dataset(split=split, as_supervised=True)
if dataset_name in ['imagenet_resized/64x64', 'caltech_birds2011']:
data_dir = os.path.join(zca_path,
'{}_{}_res{}_block{}_mean{}'.format(dataset_name, preprocess_type, resolution,
block_size, use_mean_block))
if not os.path.exists(data_dir):
os.mkdir(data_dir)
if '/' in dataset_name:
name = dataset_name.split('/')[0]
else:
name = dataset_name
process2tfrecord(ds_train, ds_test, data_dir, name, img_shape, num_classes, preprocess_op,
resolution, batch_size=10000, num_per_shard=10000)
builder = tfds.builder_from_directory(data_dir)
ds_train, ds_test = builder.as_dataset(split=['train', 'test'], as_supervised=True, shuffle_files=True)
x_train, y_train, x_test, y_test = None, None, None, None
else:
x_train, y_train = load_data(ds_train, img_shape, preprocess_op, resolution, batch_size=5000)
x_test, y_test = load_data(ds_test, img_shape, preprocess_op, resolution, batch_size=5000)
ds_train = tf.data.Dataset.from_tensor_slices((x_train, y_train))
ds_test = tf.data.Dataset.from_tensor_slices((x_test, y_test))
proto_scale = {'x_proto': jnp.sqrt(3 * (resolution ** 2))}
logging.info('Resolution: {}'.format(resolution))
logging.info('Proto Scale: {}'.format(proto_scale))
with config.unlocked():
config.img_shape = (resolution, resolution, 3) if None in img_shape else img_shape
config.num_classes = num_classes
config.class_names = class_names
config.train_size = num_train
config.test_size = num_test
if return_raw:
return (x_train, y_train, x_test, y_test), preprocess_op, rev_preprocess_op, proto_scale
else:
return (ds_train, ds_test), preprocess_op, rev_preprocess_op, proto_scale
| 8,694 | 42.914141 | 119 | py |
RCIG | RCIG-master/utils.py | import functools
import jax
import operator
import numpy as np
import jax.numpy as jnp
class bind(functools.partial):
"""
An improved version of partial which accepts Ellipsis (...) as a placeholder
"""
def __call__(self, *args, **keywords):
keywords = {**self.keywords, **keywords}
iargs = iter(args)
args = (next(iargs) if arg is ... else arg for arg in self.args)
return self.func(*args, *iargs, **keywords)
def _sub(x, y):
return jax.tree_util.tree_map(operator.sub, x, y)
def _add(x, y):
return jax.tree_util.tree_map(operator.add, x, y)
def _multiply(x, y):
return jax.tree_util.tree_map(operator.mul, x, y)
def _divide(x, y):
return jax.tree_util.tree_map(operator.truediv, x, y)
def _one_like(x):
return jax.tree_util.tree_map(lambda a: jnp.ones_like(a), x)
def get_class_indices(train_labels, samples_per_class, seed = 0, n_classes = 10):
np.random.seed(seed)
combined_indices = []
for c in range(n_classes):
class_indices = np.where(train_labels.numpy() == c)[0]
combined_indices.extend(class_indices[np.random.choice(len(class_indices), samples_per_class, replace = False)])
return combined_indices
def _zero_like(x):
return jax.tree_util.tree_map(lambda x: jnp.zeros_like(x), x)
def multiply_by_scalar(x, s):
return jax.tree_util.tree_map(lambda x: s * x, x) | 1,404 | 27.673469 | 120 | py |
RCIG | RCIG-master/imagenette.py | """Imagenette: a subset of 10 easily classified classes from Imagenet.
(tench, English springer, cassette player, chain saw, church, French horn,
garbage truck, gas pump, golf ball, parachute)
"""
import os
import tensorflow as tf
import tensorflow_datasets.public_api as tfds
_IMAGENETTE_URL = "https://s3.amazonaws.com/fast-ai-imageclas/imagenette2-160.tgz"
_CITATION = """
@misc{imagenette,
author = "Jeremy Howard",
title = "imagenette",
url = "https://github.com/fastai/imagenette/"
}
"""
_DESCRIPTION = """\
Imagenette is a subset of 10 easily classified classes from the Imagenet
dataset. It was originally prepared by Jeremy Howard of FastAI. The objective
behind putting together a small version of the Imagenet dataset was mainly
because running new ideas/algorithms/experiments on the whole Imagenet take a
lot of time.
Note: The v2 config correspond to the new 70/30 train/valid split (released
in Dec 6 2019).
"""
lbl_dict = {
'n01440764': 'tench',
'n02102040': 'english springer',
'n02979186': 'cassette player',
'n03000684': 'chain saw',
'n03028079': 'church',
'n03394916': 'french horn',
'n03417042': 'garbage truck',
'n03425413': 'gas pump',
'n03445777': 'golf ball',
'n03888257': 'parachute'
}
# Use V2 to avoid name collision with tfds
class ImagenetteV2(tfds.core.GeneratorBasedBuilder):
"""A smaller subset of 10 easily classified classes from Imagenet."""
VERSION = tfds.core.Version("1.0.0")
def _info(self):
return tfds.core.DatasetInfo(
builder=self,
description=_DESCRIPTION,
features=tfds.features.FeaturesDict({
"image": tfds.features.Image(),
"label": tfds.features.ClassLabel(
names=['tench', 'english springer', 'cassette player', 'chain saw', 'church', 'french horn',
'garbage truck', 'gas pump', 'golf ball', 'parachute']),
}),
supervised_keys=("image", "label"),
homepage="https://github.com/fastai/imagenette",
citation=_CITATION,
)
def _split_generators(self, dl_manager):
"""Generate Splits"""
extracted_path = dl_manager.download_and_extract(_IMAGENETTE_URL)
extracted_path = os.path.join(extracted_path, 'imagenette2-160')
# Specify the splits
return [
tfds.core.SplitGenerator(
name=tfds.Split.TRAIN,
gen_kwargs={
"images_dir_path": os.path.join(extracted_path, "train"),
}),
tfds.core.SplitGenerator(
name=tfds.Split.VALIDATION,
gen_kwargs={
"images_dir_path": os.path.join(extracted_path, "val"),
}),
]
def _generate_examples(self, images_dir_path):
"""Generate examples given the image directory path"""
for image_folder in tf.io.gfile.listdir(images_dir_path):
for image_file in tf.io.gfile.listdir(os.path.join(images_dir_path,
image_folder)):
yield image_file, {
'image': '{}/{}/{}'.format(images_dir_path, image_folder,
image_file),
'label': lbl_dict[image_folder]
}
| 3,401 | 35.580645 | 112 | py |
RCIG | RCIG-master/eval.py | import sys
# sys.path.append("..")
import os
import fire
import ml_collections
from functools import partial
# from jax.config import config
# config.update("jax_enable_x64", True)
import jax
from absl import logging
import absl
import tensorflow as tf
tf.config.set_visible_devices([], 'GPU')
from dataloader import get_dataset, configure_dataloader
# from lib.dataset.dataloader import get_dataset, configure_dataloader
# from lib.models.utils import create_model
# from lib.datadistillation.utils import save_dnfr_image, save_proto_np
# from lib.datadistillation.frepo import proto_train_and_evaluate, init_proto, ProtoHolder
# from lib.training.utils import create_train_state
# from lib.dataset.augmax import get_aug_by_name
from clu import metric_writers
from collections import namedtuple
# from jax.config import config as fsf
# fsf.update("jax_enable_x64", True)
from models import ResNet18, Conv, AlexNet, VGG11
from augmax import get_aug_by_name
import numpy as np
import jax.numpy as jnp
import algorithms
import optax
import time
import pickle
from flax.training import train_state, checkpoints
import json
def get_config():
# Note that max_lr_factor and l2_regularization is found through grid search.
config = ml_collections.ConfigDict()
config.random_seed = 0
config.train_log = 'train_log'
config.train_img = 'train_img'
config.mixed_precision = False
config.resume = True
config.img_size = None
config.img_channels = None
config.num_prototypes = None
config.train_size = None
config.dataset = ml_collections.ConfigDict()
config.kernel = ml_collections.ConfigDict()
config.online = ml_collections.ConfigDict()
# Dataset
config.dataset.name = 'cifar100' # ['cifar10', 'cifar100', 'mnist', 'fashion_mnist', 'tiny_imagenet']
config.dataset.data_path = 'data/tensorflow_datasets'
config.dataset.zca_path = 'data/zca'
config.dataset.zca_reg = 0.1
# online
config.online.img_size = None
config.online.img_channels = None
config.online.mixed_precision = config.mixed_precision
config.online.optimizer = 'adam'
config.online.learning_rate = 0.0003
config.online.arch = 'dnfrnet'
config.online.output = 'feat_fc'
config.online.width = 128
config.online.normalization = 'identity'
# Kernel
config.kernel.img_size = None
config.kernel.img_channels = None
config.kernel.num_prototypes = None
config.kernel.train_size = None
config.kernel.mixed_precision = config.mixed_precision
config.kernel.resume = config.resume
config.kernel.optimizer = 'lamb'
config.kernel.learning_rate = 0.0003
config.kernel.batch_size = 1024
config.kernel.eval_batch_size = 1000
return config
def main(dataset_name = 'cifar10', data_path=None, zca_path=None, train_log=None, train_img=None, width=128, depth=3, normalization='identity', eval_lr = 0.0001, random_seed=0, message = 'eval_log', output_dir = None, max_cycles = 1000, config_path = None, checkpoint_path = None, save_name = 'eval_result', log_dir = None, eval_arch = 'conv', models_to_test = 5):
# --------------------------------------
# Setup
# --------------------------------------
if output_dir is None:
output_dir = os.path.dirname(checkpoint_path)
if log_dir is None:
log_dir = output_dir
logging.use_absl_handler()
logging.get_absl_handler().use_absl_log_file('{}, {}'.format(int(time.time()), message), './{}/'.format(log_dir))
absl.flags.FLAGS.mark_as_parsed()
logging.set_verbosity('info')
logging.info('\n\n\n{}\n\n\n'.format(message))
config = get_config()
config.random_seed = random_seed
config.train_log = train_log if train_log else 'train_log'
config.train_img = train_img if train_img else 'train_img'
config.dataset.data_path = data_path if data_path else 'data/tensorflow_datasets'
config.dataset.zca_path = zca_path if zca_path else 'data/zca'
config.dataset.name = dataset_name
(ds_train, ds_test), preprocess_op, rev_preprocess_op, proto_scale = get_dataset(config.dataset)
y_transform = lambda y: tf.one_hot(y, config.dataset.num_classes, on_value=1 - 1 / config.dataset.num_classes,
off_value=-1 / config.dataset.num_classes)
ds_train = configure_dataloader(ds_train, batch_size=config.kernel.batch_size, y_transform=y_transform,
train=True, shuffle=True)
ds_test = configure_dataloader(ds_test, batch_size=config.kernel.eval_batch_size, y_transform=y_transform,
train=False, shuffle=False)
num_classes = config.dataset.num_classes
if config.dataset.img_shape[0] in [28, 32]:
depth = 3
elif config.dataset.img_shape[0] == 64:
depth = 4
elif config.dataset.img_shape[0] == 128:
depth = 5
else:
raise Exception('Invalid resolution for the dataset')
loaded_checkpoint = checkpoints.restore_checkpoint(f'./{checkpoint_path}', None)
coreset_images = loaded_checkpoint['ema_average']['x_proto']
coreset_labels = loaded_checkpoint['ema_average']['y_proto']
if eval_arch == 'conv':
model = Conv(use_softplus = False, beta = 20., num_classes = num_classes, width = width, depth = depth, normalization = normalization)
elif eval_arch == 'resnet':
model = ResNet18(output='logit', num_classes=num_classes, pooling='avg', normalization = normalization)
elif eval_arch == 'vgg':
model = VGG11(output='logit', num_classes=num_classes, pooling='avg', normalization = normalization)
elif eval_arch == 'alexnet':
model = AlexNet(output='logit', num_classes=num_classes, pooling='avg')
use_batchnorm = normalization != 'identity'
net_forward_init, net_forward_apply = model.init, model.apply
key = jax.random.PRNGKey(random_seed)
alg_config = ml_collections.ConfigDict()
if config_path is not None:
print(f'loading config from {config_path}')
logging.info(f'loading config from {config_path}')
loaded_dict = json.loads(open('./{}'.format(config_path), 'rb').read())
loaded_dict['direct_batch_sizes'] = tuple(loaded_dict['direct_batch_sizes'])
alg_config = ml_collections.config_dict.ConfigDict(loaded_dict)
print(alg_config)
logging.info(alg_config)
if output_dir is not None:
if not os.path.exists('./{}'.format(output_dir)):
os.makedirs('./{}'.format(output_dir))
with open('./{}/config.txt'.format(output_dir), 'a') as config_file:
config_file.write(repr(alg_config))
key, valid_key = jax.random.split(key)
valid_keys = jax.random.split(valid_key, models_to_test)
batch_size = 256 if coreset_images.shape[0] > 256 else None
aug = get_aug_by_name(alg_config.test_aug, config.dataset.img_shape[0])
eval_l2 = 0.00
num_online_eval_updates = 1000 if coreset_images.shape[0] == 10 else 2000
warmup_steps = 500
learning_rate = eval_lr
warmup_fn = optax.linear_schedule(init_value=0., end_value=learning_rate, transition_steps=warmup_steps)
cosine_fn = optax.cosine_decay_schedule(init_value=learning_rate, alpha=0.01,
decay_steps=max(num_online_eval_updates - warmup_steps, 1))
learning_rate_fn = optax.join_schedules(schedules=[warmup_fn, cosine_fn], boundaries=[warmup_steps])
if alg_config.use_flip:
coreset_images = jnp.concatenate([coreset_images, jnp.flip(coreset_images, -2)], 0)
coreset_labels = jnp.concatenate([coreset_labels, coreset_labels], 0 )
logging.info('no data augmentation')
acc_dict = {}
accs = []
for g in range(models_to_test):
key, aug_key = jax.random.split(key)
new_params = net_forward_init(valid_keys[g], coreset_images)
if not use_batchnorm:
bum = algorithms.TrainStateWithBatchStats.create(apply_fn = net_forward_apply, params = new_params['params'], tx = optax.chain(optax.adam(learning_rate_fn)), batch_stats = None, train_it = 0)
for g in range(num_online_eval_updates//200):
print(f'train checkpoint {(g) * 200} acc {algorithms.eval_on_test_set(bum, ds_test, has_bn = False, centering = False)}')
bum, losses = algorithms.do_training_steps(bum, {'images': coreset_images, 'labels': coreset_labels}, aug_key, n_steps = 500, l2 = eval_l2, has_bn = False, train = False, batch_size = batch_size, max_batch_size = coreset_images.shape[0])
accs.append(algorithms.eval_on_test_set(bum, ds_test, has_bn = False, centering = False))
else:
bum = algorithms.TrainStateWithBatchStats.create(apply_fn = net_forward_apply, params = new_params['params'], tx = optax.chain(optax.adam(learning_rate_fn)), batch_stats = new_params['batch_stats'], train_it = 0)
for g in range(num_online_eval_updates//200):
print(f'train checkpoint {(g) * 200} acc {algorithms.eval_on_test_set(bum, ds_test, has_bn = True, centering = False)}')
bum, losses = algorithms.do_training_steps(bum, {'images': coreset_images, 'labels': coreset_labels}, aug_key, n_steps = 500, l2 = eval_l2, has_bn = True, train = True, batch_size = batch_size, max_batch_size = coreset_images.shape[0])
accs.append(algorithms.eval_on_test_set(bum, ds_test, has_bn = True, centering = False))
print(accs)
logging.info('no data augmentation avg: {:.2f} pm {:.2f}'.format(100 * np.mean(accs), 100 * np.std(accs)))
print('no data augmentation avg: {:.2f} pm {:.2f}'.format(100 * np.mean(accs), 100 * np.std(accs)))
acc_dict['no_DA'] = np.array(accs)
accs = []
logging.info('with data augmentation')
for g in range(models_to_test):
key, aug_key = jax.random.split(key)
new_params = net_forward_init(valid_keys[g], coreset_images)
if not use_batchnorm:
bum = algorithms.TrainStateWithBatchStats.create(apply_fn = net_forward_apply, params = new_params['params'], tx = optax.chain(optax.adam(learning_rate_fn)), batch_stats = None, train_it = 0)
for g in range(num_online_eval_updates//500):
print(f'train checkpoint {(g) * 500} acc {algorithms.eval_on_test_set(bum, ds_test, has_bn = False, centering = False)}')
bum, losses = algorithms.do_training_steps(bum, {'images': coreset_images, 'labels': coreset_labels}, aug_key, n_steps = 500, l2 = eval_l2, has_bn = False, train = False, aug = aug, batch_size = batch_size, max_batch_size = coreset_images.shape[0])
accs.append(algorithms.eval_on_test_set(bum, ds_test, has_bn = False, centering = False))
else:
bum = algorithms.TrainStateWithBatchStats.create(apply_fn = net_forward_apply, params = new_params['params'], tx = optax.chain(optax.adam(learning_rate_fn)), batch_stats = new_params['batch_stats'], train_it = 0)
for g in range(num_online_eval_updates//500):
print(f'train checkpoint {(g) * 500} acc {algorithms.eval_on_test_set(bum, ds_test, has_bn = True, centering = False)}')
bum, losses = algorithms.do_training_steps(bum, {'images': coreset_images, 'labels': coreset_labels}, aug_key, n_steps = 500, l2 = eval_l2, has_bn = True, train = True, aug = aug, batch_size = batch_size, max_batch_size = coreset_images.shape[0])
accs.append(algorithms.eval_on_test_set(bum, ds_test, has_bn = True, centering = False))
print(accs)
logging.info('with data augmentation avg: {:.2f} pm {:.2f}'.format(100 * np.mean(accs), 100 * np.std(accs)))
print('with data augmentation avg: {:.2f} pm {:.2f}'.format(100 * np.mean(accs), 100 * np.std(accs)))
acc_dict['DA'] = np.array(accs)
if output_dir is not None:
pickle.dump(acc_dict, open('./{}/{}.pkl'.format(output_dir, save_name), 'wb'))
if __name__ == '__main__':
tf.config.experimental.set_visible_devices([], 'GPU')
fire.Fire(main) | 12,140 | 41.6 | 364 | py |
RCIG | RCIG-master/imagewoof.py | import os
import tensorflow as tf
import tensorflow_datasets.public_api as tfds
_IMAGEWOOF_URL = "https://s3.amazonaws.com/fast-ai-imageclas/imagewoof2-160.tgz"
_CITATION = """
@misc{imagewoof,
author = "Jeremy Howard",
title = "Imagewoof",
url = "https://github.com/fastai/imagenette/"
}
"""
_DESCRIPTION = """\
Imagewoof is a subset of 10 classes from Imagenet that aren't so easy to
classify, since they're all dog breeds. The breeds are: Australian terrier,
Border terrier, Samoyed, Beagle, Shih-Tzu, English foxhound, Rhodesian
ridgeback, Dingo, Golden retriever, Old English sheepdog.
"""
lbl_dict = {
'n02093754': 'Australian terrier',
'n02089973': 'Border terrier',
'n02099601': 'Samoyed',
'n02087394': 'Beagle',
'n02105641': 'Shih-Tzu',
'n02096294': 'English foxhound',
'n02088364': 'Rhodesian ridgeback',
'n02115641': 'Dingo',
'n02111889': 'Golden retriever',
'n02086240': 'Old English sheepdog'
}
# Use V2 to avoid name collision with tfds
class ImagewoofV2(tfds.core.GeneratorBasedBuilder):
"""Imagewoof Dataset"""
VERSION = tfds.core.Version('1.0.0')
def _info(self):
return tfds.core.DatasetInfo(
builder=self,
description=_DESCRIPTION,
features=tfds.features.FeaturesDict({
"image": tfds.features.Image(),
"label": tfds.features.ClassLabel(
names=['Border terrier', 'English foxhound', 'Golden retriever', 'Rhodesian ridgeback',
'Old English sheepdog', 'Australian terrier', 'Beagle', 'Dingo', 'Samoyed', 'Shih-Tzu']),
}),
supervised_keys=("image", "label"),
homepage="https://github.com/fastai/imagenette",
citation=_CITATION
)
def _split_generators(self, dl_manager):
"""Generate Splits"""
extracted_path = dl_manager.download_and_extract(_IMAGEWOOF_URL)
extracted_path = os.path.join(extracted_path, 'imagewoof2-160')
# Specify the splits
return [
tfds.core.SplitGenerator(
name=tfds.Split.TRAIN,
gen_kwargs={
"images_dir_path": os.path.join(extracted_path, "train"),
}),
tfds.core.SplitGenerator(
name=tfds.Split.VALIDATION,
gen_kwargs={
"images_dir_path": os.path.join(extracted_path, "val"),
}),
]
def _generate_examples(self, images_dir_path):
"""Generate examples given the image directory path"""
for image_folder in tf.io.gfile.listdir(images_dir_path):
for image_file in tf.io.gfile.listdir(os.path.join(images_dir_path,
image_folder)):
yield image_file, {
'image': '{}/{}/{}'.format(images_dir_path, image_folder,
image_file),
'label': lbl_dict[image_folder]
}
| 3,072 | 36.024096 | 116 | py |
RCIG | RCIG-master/models.py | #A lot of this code is reused from https://github.com/yongchao97/FRePo
from functools import partial
from typing import Any, Callable, Sequence, Tuple
from flax import linen as nn
import jax.numpy as jnp
import jax
import functools
ModuleDef = Any
class KIP_ConvNet(nn.Module):
depth: int = 3
width: int = 128
kernel_size: tuple = (3, 3)
activation_fn: Callable = nn.relu
use_gap: bool = False
num_classes: int = 10
kernel_init: functools.partial = nn.initializers.lecun_normal()
bias_init: functools.partial = functools.partial(nn.initializers.normal, stddev=0.1)()
normalization: str = 'identity'
pooling: str = 'avg'
output: str = 'softmax'
dtype: str = 'float32'
@nn.compact
def __call__(self, x, train=True, features = False):
if self.output not in ['softmax', 'log_softmax', 'logit', 'activations', 'feat_conv', 'feat_fc']:
raise ValueError(
'Wrong argument. Possible choices for output are "softmax", "log_softmax", "logit", "activations", "feat_conv", and "feat_fc".')
act = {}
if self.normalization == 'batch':
norm_layer = functools.partial(nn.BatchNorm,
use_running_average=not train,
epsilon=1e-05,
momentum=0.1,
dtype=self.dtype)
elif self.normalization == 'layer':
norm_layer = functools.partial(nn.LayerNorm, dtype=self.dtype)
elif self.normalization == 'group':
norm_layer = functools.partial(nn.GroupNorm, dtype=self.dtype)
elif self.normalization == 'group1':
norm_layer = functools.partial(nn.GroupNorm, num_groups=1, dtype=self.dtype)
elif self.normalization == 'instance':
norm_layer = functools.partial(nn.GroupNorm, num_groups=None, group_size=1, dtype=self.dtype)
elif self.normalization == 'identity':
norm_layer = None
else:
raise ValueError('Unknown Normalization Layer {}!'.format(self.normalization))
if self.pooling == 'avg':
pool_layer = nn.avg_pool
elif self.pooling == 'max':
pool_layer = nn.max_pool
elif self.pooling == 'identity':
pool_layer = lambda x, *args, **kargs: x
else:
raise ValueError('Unknown Pooling Layer {}!'.format(self.pooling))
x = nn.Conv(features=self.width, kernel_size=self.kernel_size, kernel_init=self.kernel_init, use_bias=True,
dtype=self.dtype)(x)
act['conv0'] = x
x = self.activation_fn(x)
# generate blocks of convolutions followed by average pooling (n, 32, 32, 512)
for i in range(self.depth):
if not self.normalization == 'identity':
x = norm_layer()(x)
x = nn.Conv(features=self.width, kernel_size=self.kernel_size, kernel_init=self.kernel_init, use_bias=True,
dtype=self.dtype)(x)
act['conv{}'.format(i + 1)] = x
x = self.activation_fn(x)
x = pool_layer(x, (2, 2), strides=(2, 2))
feat_conv = x # (n, 4, 4, 512)
if self.use_gap:
x = nn.avg_pool(x, x.shape[1:3])
x = x.reshape((x.shape[0], -1))
else:
x = x.reshape((x.shape[0], -1))
feat_fc = x
# feats.append(feat_fc)
x = nn.Dense(features=self.num_classes,
kernel_init=self.kernel_init,
bias_init=self.bias_init,
dtype=self.dtype)(x)
act['fc'] = x # (n, 512)
if features:
return feat_fc
return x
class Conv(nn.Module):
depth: int = 3
width: int = 128
kernel_size: tuple = (3, 3)
num_classes: int = 10
normalization: str = 'identity'
pooling: str = 'avg'
output: str = 'softmax'
dtype: str = 'float32'
use_softplus: bool = False
beta: float = 1.
final_layer_bias: bool = True
@nn.compact
def __call__(self, x, train=True, features = False):
channel = x.shape[-1]
if self.normalization == 'batch':
norm_layer = functools.partial(nn.BatchNorm, use_running_average=not train, epsilon=1e-05, momentum=0.1,
dtype=self.dtype)
elif self.normalization == 'layer':
norm_layer = functools.partial(nn.LayerNorm, dtype=self.dtype)
elif self.normalization == 'group':
norm_layer = functools.partial(nn.GroupNorm, dtype=self.dtype)
elif self.normalization == 'group1':
norm_layer = functools.partial(nn.GroupNorm, num_groups=1, dtype=self.dtype)
elif self.normalization == 'instance':
norm_layer = functools.partial(nn.GroupNorm, num_groups=None, group_size=1, dtype=self.dtype)
elif self.normalization == 'identity':
norm_layer = None
else:
raise ValueError('Unknown Normalization Layer {}!'.format(self.normalization))
for i in range(self.depth):
# if i != 0 and self.normalization != 'identity':
# x = norm_layer()(x)
if i == 0 and channel == 1:
pad = (self.kernel_size[0] // 2 + 2, self.kernel_size[0] // 2 + 2)
else:
pad = (self.kernel_size[0] // 2, self.kernel_size[0] // 2)
x = nn.Conv(features=self.width * (2 ** i), kernel_size=self.kernel_size,
padding=(pad, pad), use_bias=True, dtype=self.dtype)(x)
if not self.normalization == 'identity':
x = norm_layer()(x)
# x = nn.relu(x)
if self.use_softplus:
x = nn.softplus(self.beta * x)/self.beta
else:
x = nn.relu(x)
x = nn.avg_pool(x, (2, 2), strides=(2, 2))
x = x.reshape((x.shape[0], -1))
feat_fc = x
x = nn.Dense(features=self.num_classes, dtype=self.dtype, use_bias = self.final_layer_bias)(x)
if not features:
return x
return x, feat_fc
class linear_net(nn.Module):
depth: int = 3
width: int = 128
kernel_size: tuple = (3, 3)
activation_fn: Callable = nn.relu
use_gap: bool = False
num_classes: int = 10
kernel_init: functools.partial = nn.initializers.lecun_normal()
bias_init: functools.partial = functools.partial(nn.initializers.normal, stddev=0.1)()
normalization: str = 'identity'
pooling: str = 'avg'
output: str = 'softmax'
dtype: str = 'float32'
@nn.compact
def __call__(self, x, train=True, features = False):
x = x.reshape((x.shape[0], -1))
feat_fc = x
# feats.append(feat_fc)
x = nn.Dense(features=self.num_classes,
kernel_init=self.kernel_init,
bias_init=self.bias_init,
dtype=self.dtype, use_bias = False)(x)
# act['fc'] = x # (n, 512)
return x
class AlexNet(nn.Module):
num_classes: int = 10
pooling: str = 'max'
output: str = 'softmax'
dtype: str = 'float32'
@nn.compact
def __call__(self, x, train=True):
channel = x.shape[-1]
if self.output not in ['softmax', 'log_softmax', 'logit', 'feat_fc']:
raise ValueError(
'Wrong argument. Possible choices for output are "softmax", "log_softmax", "logit",and "feat_fc".')
if self.pooling == 'avg':
pool_layer = nn.avg_pool
elif self.pooling == 'max':
pool_layer = nn.max_pool
elif self.pooling == 'identity':
pool_layer = lambda x, *args, **kargs: x
else:
raise ValueError('Unknown Pooling Layer {}!'.format(self.pooling))
if channel == 1:
pad = (5 // 2 + 2, 5 // 2 + 2)
else:
pad = (5 // 2, 5 // 2)
x = nn.Conv(features=128, kernel_size=(5, 5), padding=(pad, pad))(x)
x = pool_layer(nn.relu(x), (2, 2), strides=(2, 2))
x = nn.Conv(features=192, kernel_size=(5, 5), padding='SAME')(x)
x = pool_layer(nn.relu(x), (2, 2), strides=(2, 2))
x = nn.Conv(features=256, kernel_size=(3, 3), padding='SAME')(x)
x = nn.relu(x)
x = nn.Conv(features=192, kernel_size=(3, 3), padding='SAME')(x)
x = nn.relu(x)
x = nn.Conv(features=192, kernel_size=(3, 3), padding='SAME')(x)
x = pool_layer(nn.relu(x), (2, 2), strides=(2, 2))
x = x.reshape((x.shape[0], -1))
feat_fc = x
x = nn.Dense(features=self.num_classes)(x)
if self.output == 'logit':
return x
if self.output == 'softmax':
return nn.softmax(x)
if self.output == 'log_softmax':
return nn.log_softmax(x)
if self.output == 'feat_fc':
return x, feat_fc
''' VGG '''
cfg_vgg = {
'VGG11': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
'VGG13': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
'VGG16': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],
'VGG19': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],
}
class VGG(nn.Module):
architecture: str = 'VGG11'
num_classes: int = 10
pooling: str = 'max'
normalization: str = 'identity'
output: str = 'softmax'
dtype: str = 'float32'
@nn.compact
def __call__(self, x, train=True):
channel = x.shape[-1]
cfg = cfg_vgg[self.architecture]
if self.output not in ['softmax', 'log_softmax', 'logit', 'feat_fc']:
raise ValueError(
'Wrong argument. Possible choices for output are "softmax", "log_softmax", "logit",and "feat_fc".')
if self.pooling == 'avg':
pool_layer = nn.avg_pool
elif self.pooling == 'max':
pool_layer = nn.max_pool
elif self.pooling == 'identity':
pool_layer = lambda x, *args, **kargs: x
else:
raise ValueError('Unknown Pooling Layer {}!'.format(self.pooling))
if self.normalization == 'batch':
norm_layer = functools.partial(nn.BatchNorm, use_running_average=not train, momentum=0.9)
elif self.normalization == 'layer':
norm_layer = functools.partial(nn.LayerNorm, dtype=self.dtype)
elif self.normalization == 'group':
norm_layer = functools.partial(nn.GroupNorm, dtype=self.dtype)
elif self.normalization == 'group1':
norm_layer = functools.partial(nn.GroupNorm, num_groups=1, dtype=self.dtype)
elif self.normalization == 'instance':
norm_layer = functools.partial(nn.GroupNorm, num_groups=None, group_size=1, dtype=self.dtype)
elif self.normalization == 'identity':
norm_layer = lambda: lambda x: x
else:
raise ValueError('Unknown Normalization Layer {}!'.format(self.normalization))
if channel == 1:
pad = (3 // 2 + 2, 3 // 2 + 2)
else:
pad = (3 // 2, 3 // 2)
for ic, w in enumerate(cfg):
if w == 'M':
x = pool_layer(x, (2, 2), strides=(2, 2))
else:
if ic == 0:
x = nn.Conv(features=128, kernel_size=(3, 3), padding=(pad, pad))(x)
else:
x = nn.Conv(features=128, kernel_size=(3, 3), padding='SAME')(x)
x = norm_layer()(x)
x = nn.relu(x)
x = x.reshape((x.shape[0], -1))
feat_fc = x
x = nn.Dense(features=self.num_classes)(x)
if self.output == 'logit':
return x
if self.output == 'softmax':
return nn.softmax(x)
if self.output == 'log_softmax':
return nn.log_softmax(x)
if self.output == 'feat_fc':
return x, feat_fc
def VGG11(num_classes, pooling, normalization, output):
return VGG('VGG11', num_classes, pooling, normalization, output)
def VGG13(num_classes, pooling, normalization, output):
return VGG('VGG13', num_classes, pooling, normalization, output)
def VGG16(num_classes, pooling, normalization, output):
return VGG('VGG16', num_classes, pooling, normalization, output)
def VGG19(num_classes, pooling, normalization, output):
return VGG('VGG19', num_classes, pooling, normalization, output)
''' ResNet '''
LAYERS = {'resnet18': [2, 2, 2, 2],
'resnet34': [3, 4, 6, 3],
'resnet50': [3, 4, 6, 3],
'resnet101': [3, 4, 23, 3],
'resnet152': [3, 8, 36, 3],
'resnet20': [3, 3, 3],
'resnet32': [5, 5, 5],
'resnet44': [7, 7, 7],
'resnet56': [9, 9, 9],
'resnet110': [18, 18, 18],
}
class BasicBlock(nn.Module):
features: int
stride: int = 1
kernel_size: tuple = (3, 3)
normalization: str = 'identity'
block_name: str = None
dtype: str = 'float32'
@nn.compact
def __call__(self, x, train=True):
"""
Run Basic Block.
Args:
x (tensor): Input tensor of shape [N, H, W, C].
act (dict): Dictionary containing activations.
train (bool): Training mode.
Returns:
(tensor): Output shape of shape [N, H', W', features].
"""
if self.normalization == 'batch':
norm_layer = functools.partial(nn.BatchNorm, use_running_average=not train, momentum=0.9)
elif self.normalization == 'layer':
norm_layer = functools.partial(nn.LayerNorm, dtype=self.dtype)
elif self.normalization == 'group':
norm_layer = functools.partial(nn.GroupNorm, dtype=self.dtype)
elif self.normalization == 'group1':
norm_layer = functools.partial(nn.GroupNorm, num_groups=1, dtype=self.dtype)
elif self.normalization == 'instance':
norm_layer = functools.partial(nn.GroupNorm, num_groups=None, group_size=1, dtype=self.dtype)
elif self.normalization == 'identity':
norm_layer = lambda: lambda x: x
else:
raise ValueError('Unknown Normalization Layer {}!'.format(self.normalization))
residual = x
x = nn.Conv(features=self.features, kernel_size=self.kernel_size, strides=(self.stride, self.stride),
padding=((1, 1), (1, 1)), use_bias=False, dtype=self.dtype)(x)
x = norm_layer()(x)
x = nn.relu(x)
x = nn.Conv(features=self.features, kernel_size=self.kernel_size, strides=(1, 1),
padding=((1, 1), (1, 1)), use_bias=False, dtype=self.dtype)(x)
x = norm_layer()(x)
if self.stride != 1 or (x.shape[-1] != residual.shape[-1]):
residual = nn.Conv(features=self.features, kernel_size=(1, 1), strides=(self.stride, self.stride),
use_bias=False, dtype=self.dtype)(residual)
residual = norm_layer()(residual)
x += residual
x = nn.relu(x)
return x
class BasicBlock_AP(nn.Module):
features: int
stride: int = 1
kernel_size: tuple = (3, 3)
pooling: str = 'max'
normalization: str = 'identity'
block_name: str = None
dtype: str = 'float32'
@nn.compact
def __call__(self, x, train=True):
"""
Run Basic Block.
Args:
x (tensor): Input tensor of shape [N, H, W, C].
act (dict): Dictionary containing activations.
train (bool): Training mode.
Returns:
(tensor): Output shape of shape [N, H', W', features].
"""
if self.pooling == 'avg':
pool_layer = nn.avg_pool
elif self.pooling == 'max':
pool_layer = nn.max_pool
elif self.pooling == 'identity':
pool_layer = lambda x, *args, **kargs: x
else:
raise ValueError('Unknown Pooling Layer {}!'.format(self.pooling))
if self.normalization == 'batch':
norm_layer = functools.partial(nn.BatchNorm, use_running_average=not train, momentum=0.9)
elif self.normalization == 'layer':
norm_layer = functools.partial(nn.LayerNorm, dtype=self.dtype)
elif self.normalization == 'group':
norm_layer = functools.partial(nn.GroupNorm, dtype=self.dtype)
elif self.normalization == 'group1':
norm_layer = functools.partial(nn.GroupNorm, num_groups=1, dtype=self.dtype)
elif self.normalization == 'instance':
norm_layer = functools.partial(nn.GroupNorm, num_groups=None, group_size=1, dtype=self.dtype)
elif self.normalization == 'identity':
norm_layer = lambda: lambda x: x
else:
raise ValueError('Unknown Normalization Layer {}!'.format(self.normalization))
residual = x
x = nn.Conv(features=self.features, kernel_size=self.kernel_size, strides=(1, 1),
padding=((1, 1), (1, 1)), use_bias=False, dtype=self.dtype)(x)
x = norm_layer()(x)
x = nn.relu(x)
if self.stride != 1:
x = pool_layer(x, (2, 2), strides=(2, 2))
x = nn.Conv(features=self.features, kernel_size=self.kernel_size, strides=(1, 1),
padding=((1, 1), (1, 1)), use_bias=False, dtype=self.dtype)(x)
x = norm_layer()(x)
if self.stride != 1 or (x.shape[-1] != residual.shape[-1]):
residual = nn.Conv(features=self.features, kernel_size=(1, 1), strides=(1, 1),
use_bias=False, dtype=self.dtype)(residual)
if self.stride != 1:
residual = pool_layer(residual, (2, 2), strides=(2, 2))
residual = norm_layer()(residual)
x += residual
x = nn.relu(x)
return x
class ResNet(nn.Module):
"""
ResNet.
Attributes:
output (str):
Output of the module. Available options are:
- 'softmax': Output is a softmax tensor of shape [N, 1000]
- 'log_softmax': Output is a softmax tensor of shape [N, 1000]
- 'logit': Output is a tensor of shape [N, 1000]
- 'activations': Output is a dictionary containing the ResNet activations
pretrained (str):
Indicates if and what type of weights to load. Options are:
- 'imagenet': Loads the network parameters trained on ImageNet
- None: Parameters of the module are initialized randomly
normalize (bool):
If True, the input will be normalized with the ImageNet statistics.
architecture (str):
Which ResNet model to use:
- 'resnet18'
- 'resnet34'
- 'resnet50'
- 'resnet101'
- 'resnet152'
num_classes (int):
Number of classes.
block (nn.Module):
Type of residual block:
- BasicBlock
- Bottleneck
ckpt_dir (str):
The directory to which the pretrained weights are downloaded.
Only relevant if a pretrained model is used.
If this argument is None, the weights will be saved to a temp directory.
dtype (str): Data type.
"""
architecture: str = 'resnet18'
num_classes: int = 10
normalization: str = 'identity'
block: nn.Module = BasicBlock
output: str = 'softmax'
dtype: str = 'float32'
@nn.compact
def __call__(self, x, train=True):
"""
Args:
x (tensor): Input tensor of shape [N, H, W, 3]. Images must be in range [0, 1].
train (bool): Training mode.
Returns:
(tensor): Out
If output == 'logit' or output == 'softmax':
(tensor): Output tensor of shape [N, num_classes].
If output == 'activations':
(dict): Dictionary of activations.
"""
if self.normalization == 'batch':
norm_layer = functools.partial(nn.BatchNorm, use_running_average=not train, momentum=0.9)
elif self.normalization == 'layer':
norm_layer = functools.partial(nn.LayerNorm, dtype=self.dtype)
elif self.normalization == 'group':
norm_layer = functools.partial(nn.GroupNorm, dtype=self.dtype)
elif self.normalization == 'group1':
norm_layer = functools.partial(nn.GroupNorm, num_groups=1, dtype=self.dtype)
elif self.normalization == 'instance':
norm_layer = functools.partial(nn.GroupNorm, num_groups=None, group_size=1, dtype=self.dtype)
elif self.normalization == 'identity':
norm_layer = lambda: lambda x: x
else:
raise ValueError('Unknown Normalization Layer {}!'.format(self.normalization))
x = nn.Conv(features=64, kernel_size=(3, 3), use_bias=False, dtype=self.dtype)(x)
x = norm_layer()(x)
x = nn.relu(x)
for i in range(LAYERS[self.architecture][0]):
x = self.block(features=64, kernel_size=(3, 3), stride=1,
block_name=f'block1_{i}', dtype=self.dtype)(x, train)
for i in range(LAYERS[self.architecture][1]):
x = self.block(features=128, kernel_size=(3, 3), stride=2 if i == 0 else 1,
block_name=f'block1_{i}', dtype=self.dtype)(x, train)
for i in range(LAYERS[self.architecture][2]):
x = self.block(features=256, kernel_size=(3, 3), stride=2 if i == 0 else 1,
block_name=f'block2_{i}', dtype=self.dtype)(x, train)
for i in range(LAYERS[self.architecture][3]):
x = self.block(features=512, kernel_size=(3, 3), stride=2 if i == 0 else 1,
block_name=f'block3_{i}', dtype=self.dtype)(x, train)
# Classifier
x = x.reshape((x.shape[0], -1))
feat_fc = x # (n, 64)
x = nn.Dense(features=self.num_classes, dtype=self.dtype)(x)
if self.output == 'logit':
return x
if self.output == 'softmax':
return nn.softmax(x)
if self.output == 'log_softmax':
return nn.log_softmax(x)
if self.output == 'feat_fc':
return x, feat_fc
def ResNet18(num_classes, pooling, normalization, output):
return ResNet('resnet18', num_classes, normalization, BasicBlock, output)
def ResNet18_AP(num_classes, pooling, normalization, output):
return ResNet('resnet18', num_classes, normalization, BasicBlock_AP, output) | 22,826 | 36.60626 | 144 | py |
RCIG | RCIG-master/ops.py | #A lot of this code is reused from https://github.com/yongchao97/FRePo
import tqdm
import functools
from absl import logging
import jax
import jax.numpy as jnp
import numpy as np
import tensorflow as tf
import tensorflow_datasets as tfds
def blockshaped(arr, h, w, c, nrows, ncols, is_tf=False):
"""
Return an array of shape (n, nrows * ncols * c) where
n * nrows * ncols * c= arr.size
If arr is a 2D array, the returned array should look like n subblocks with
each subblock preserving the "physical" layout of arr.
"""
if is_tf:
arr = tf.reshape(arr, shape=(h // nrows, nrows, w // ncols, ncols, c))
arr = tf.transpose(arr, perm=[0, 2, 1, 3, 4])
arr = tf.reshape(arr, shape=(-1, nrows * ncols * c))
return arr
else:
return arr.reshape(h // nrows, nrows, w // ncols, ncols, c).swapaxes(1, 2).reshape(-1, nrows * ncols * c)
def unblockshaped(arr, h, w, c, nrows, ncols, is_tf=False):
"""
Return an array of shape (h, w, c) where
h * w * c = arr.size
If arr is of shape (n, nrows * ncols * c), n sublocks of shape (nrows * ncols * c),
then the returned array preserves the "physical" layout of the sublocks.
"""
if is_tf:
arr = tf.reshape(arr, shape=(h // nrows, w // ncols, nrows, ncols, c))
arr = tf.transpose(arr, perm=[0, 2, 1, 3, 4])
arr = tf.reshape(arr, shape=(h, w, c))
return arr
else:
return arr.reshape(h // nrows, w // ncols, nrows, ncols, c).swapaxes(1, 2).reshape(h, w, c)
def checkboardshaped(arr, h, w, c, nrows, ncols, is_tf=False):
stride_row = h // nrows
stride_col = w // ncols
arr = arr.reshape(h, w, c)
new_arr = jnp.zeros(shape=(stride_row, stride_col, nrows, ncols, c))
for i in range(h // nrows):
for j in range(w // ncols):
new_arr = new_arr.at[i, j, :, :, :].set(arr[i::stride_row, j::stride_col, :])
return new_arr.reshape(-1, nrows * ncols * c)
def uncheckboardshaped(arr, h, w, c, nrows, ncols, is_tf=False):
arr = arr.reshape(h // nrows, w // ncols, nrows, ncols, c)
new_arr = jnp.zeros(shape=(h, w, c))
for i in range(h // nrows):
for j in range(w // ncols):
new_arr = new_arr.at[i::h // nrows, j::w // ncols, :].set(arr[i, j, :, :, :])
return new_arr
def center_crop(x, resolution):
shape = tf.shape(x)
h, w = shape[0], shape[1]
size = tf.minimum(h, w)
begin = tf.cast([h - size, w - size], tf.float32) / 2.0
begin = tf.cast(begin, tf.int32)
begin = tf.concat([begin, [0]], axis=0) # Add channel dimension.
x = tf.slice(x, begin, [size, size, 3])
x = tf.image.resize_with_pad(x, resolution, resolution, method='area', antialias=True)
return x
def compute_zca_mean_cov_ds(ds, img_shape, mean=None, std=None, resolution=32, block_size=None, batch_size=1000,
use_checkboard=False):
rows = img_shape[0] if img_shape[0] is not None else resolution
cols = img_shape[1] if img_shape[1] is not None else resolution
channels = img_shape[2] if img_shape[2] is not None else 3
dim = rows * cols * channels
ds = ds.map(lambda x, y: tf.cast(x, dtype='float32') / 255.0, tf.data.AUTOTUNE)
if None in img_shape:
ds = ds.map(lambda x: center_crop(x, resolution), tf.data.AUTOTUNE)
if mean is not None:
ds = ds.map(lambda x: (x - mean) / std, tf.data.AUTOTUNE)
ds = ds.map(lambda x: tf.reshape(x, shape=(dim,)), tf.data.AUTOTUNE)
ds = ds.batch(batch_size=batch_size)
ds = ds.prefetch(buffer_size=tf.data.AUTOTUNE)
zca_sum = jnp.zeros(shape=(dim,))
count = 0
if block_size is not None:
assert rows % block_size == 0, 'rows ({}) is not evenly divisible by block_size ({})'.format(rows, block_size)
assert cols % block_size == 0, 'cols ({}) is not evenly divisible by block_size ({})'.format(cols, block_size)
block_dim = block_size * block_size * channels
cov_sum = jnp.zeros(shape=(dim // block_dim, block_dim, block_dim))
else:
cov_sum = jnp.zeros(shape=(dim, dim))
for x_batch in tqdm.tqdm(tfds.as_numpy(ds), desc='Compute ZCA Mean with batch size: {}'.format(batch_size)):
zca_sum = zca_sum + jnp.sum(x_batch, axis=0)
count += x_batch.shape[0]
zca_mean = 1.0 / count * zca_sum
if use_checkboard:
reshape_op = jax.vmap(functools.partial(checkboardshaped, nrows=block_size, ncols=block_size, is_tf=False),
in_axes=(0, None, None, None))
else:
reshape_op = jax.vmap(functools.partial(blockshaped, nrows=block_size, ncols=block_size, is_tf=False),
in_axes=(0, None, None, None))
for x_batch in tqdm.tqdm(tfds.as_numpy(ds), desc='Compute ZCA Covariance with batch size: {}'.format(batch_size)):
x_batch = x_batch - zca_mean
if block_size is not None:
x_batch = reshape_op(x_batch, rows, cols, channels)
cov_sum = cov_sum + jnp.einsum('ijk,ijl->jkl', x_batch, x_batch)
else:
cov_sum = cov_sum + x_batch.T.dot(x_batch)
cov = 1.0 / count * cov_sum
logging.info('Total number of data: {}, ZCA Mean shape: {}, ZCA Covariance shape: {}'.format(count, zca_mean.shape,
cov.shape))
return zca_mean, cov
def compute_channel_mean_std_ds(ds, img_shape, resolution=32, batch_size=1000):
if None in img_shape:
dim = resolution * resolution
else:
dim = functools.reduce(lambda x, y: x * y, img_shape[:-1], 1)
ds = ds.map(lambda x, y: tf.cast(x, dtype='float32') / 255.0, tf.data.AUTOTUNE)
if None in img_shape:
ds = ds.map(lambda x: center_crop(x, resolution), tf.data.AUTOTUNE)
ds = ds.map(lambda x: tf.reshape(x, shape=(dim, img_shape[-1])), tf.data.AUTOTUNE)
ds = ds.batch(batch_size=batch_size)
ds = ds.prefetch(buffer_size=tf.data.AUTOTUNE)
mean = jnp.zeros(shape=(img_shape[-1],))
var = jnp.zeros(shape=(img_shape[-1],))
count = 0
for x_batch in tqdm.tqdm(tfds.as_numpy(ds), desc='Compute mean with batch size: {}'.format(batch_size)):
mean = mean + jnp.sum(x_batch, axis=(0, 1))
count += x_batch.shape[0]
mean = 1.0 / (count * dim) * mean
for x_batch in tqdm.tqdm(tfds.as_numpy(ds), desc='Compute variance with batch size: {}'.format(batch_size)):
var = var + jnp.sum(jnp.square(x_batch - mean), axis=(0, 1))
std = jnp.sqrt(1.0 / (count * dim) * var)
logging.info('Total number of data: {}, mean: {}, std: {}'.format(count, mean, std))
return mean, std
def get_whitening_transform(cov, n_train, zca_reg=1e-5, use_mean_block=False):
def _get_whitening_transform(cov, n_train, zca_reg):
"""Returns 2D matrix that performs whitening transform.
Whitening transform is a (d,d) matrix (d = number of features) which acts on
the right of a (n, d) batch of flattened data.
"""
reg_amount = zca_reg * jnp.trace(cov) / cov.shape[0]
u, s, _ = jnp.linalg.svd(cov + reg_amount * jnp.eye(cov.shape[0]))
sqrt_zca_eigs = s ** (1 / 2)
inv_sqrt_zca_eigs = s ** (-1 / 2)
# rank control
if n_train < cov.shape[0]:
sqrt_zca_eigs = sqrt_zca_eigs.at[n_train:].set(
jnp.ones(sqrt_zca_eigs[n_train:].shape[0]))
inv_sqrt_zca_eigs = inv_sqrt_zca_eigs.at[n_train:].set(
jnp.ones(inv_sqrt_zca_eigs[n_train:].shape[0]))
rev_whitening_transform = jnp.einsum('ij,j,kj->ik', u, sqrt_zca_eigs, u, optimize=True)
whitening_transform = jnp.einsum('ij,j,kj->ik', u, inv_sqrt_zca_eigs, u, optimize=True)
return whitening_transform, rev_whitening_transform, reg_amount, sqrt_zca_eigs, inv_sqrt_zca_eigs
get_transform = functools.partial(_get_whitening_transform, n_train=n_train, zca_reg=zca_reg)
jit_get_transform = jax.jit(get_transform)
logging.info('Performing zca whitening preprocessing with reg: %.2e', zca_reg)
if len(cov.shape) == 3 and use_mean_block:
logging.info('Use mean block!')
cov = jnp.mean(cov, axis=0)
if len(cov.shape) == 3:
whitening_transform = []
rev_whitening_transform = []
# Sequential form, otherwise may get OOM
for i in range(cov.shape[0]):
a, b, c, d, e = jit_get_transform(cov[i])
whitening_transform.append(a)
rev_whitening_transform.append(b)
logging.info('Raw zca regularization strength: {}'.format(c))
logging.info('sqrt_zca_eigs: {}, {}'.format(d.shape, d))
logging.info('inv_sqrt_zca_eigs: {}, {}'.format(e.shape, e))
whitening_transform = jnp.stack(whitening_transform)
rev_whitening_transform = jnp.stack(rev_whitening_transform)
else:
whitening_transform, rev_whitening_transform, c, d, e = jit_get_transform(cov)
logging.info('Raw zca regularization strength: {}'.format(c))
logging.info('sqrt_zca_eigs: {}, {}'.format(d.shape, d))
logging.info('inv_sqrt_zca_eigs: {}, {}'.format(e.shape, e))
return whitening_transform, rev_whitening_transform
def get_preprocess_op_np(mean=None, std=None, zca_mean=None, whitening_transform=None, rev_whitening_transform=None,
block_size=None, use_mean_block=False, use_checkboard=False):
if use_checkboard:
reshape_op = jax.vmap(
functools.partial(checkboardshaped, nrows=block_size, ncols=block_size, is_tf=False),
in_axes=(0, None, None, None))
unreshape_op = jax.vmap(
functools.partial(uncheckboardshaped, nrows=block_size, ncols=block_size, is_tf=False),
in_axes=(0, None, None, None))
else:
reshape_op = jax.vmap(functools.partial(blockshaped, nrows=block_size, ncols=block_size, is_tf=False),
in_axes=(0, None, None, None))
unreshape_op = jax.vmap(functools.partial(unblockshaped, nrows=block_size, ncols=block_size, is_tf=False),
in_axes=(0, None, None, None))
# This operation deals with a batch of data per time
def preprocess_op(images):
if mean is not None:
images = (images - mean) / std
if zca_mean is not None:
orig_shape = images.shape
images = images.reshape(orig_shape[0], -1)
images = images - zca_mean
if block_size is not None:
images = reshape_op(images, orig_shape[-3], orig_shape[-2], orig_shape[-1])
if use_mean_block:
images = jnp.einsum('...j,jk->...k', images, whitening_transform)
else:
images = jnp.einsum('...ij,ijk->...ik', images, whitening_transform)
images = unreshape_op(images, orig_shape[-3], orig_shape[-2], orig_shape[-1])
else:
images = jnp.einsum('...j,jk->...k', images, whitening_transform)
images = images.reshape(orig_shape)
return images
def preprocess_op_rev(images):
if zca_mean is not None:
orig_shape = images.shape
images = images.reshape(orig_shape[0], -1)
if block_size is not None:
images = reshape_op(images, orig_shape[-3], orig_shape[-2], orig_shape[-1])
if use_mean_block:
images = jnp.einsum('...j,jk->...k', images, rev_whitening_transform)
else:
images = jnp.einsum('...ij,ijk->...ik', images, rev_whitening_transform)
images = unreshape_op(images, orig_shape[-3], orig_shape[-2], orig_shape[-1])
else:
images = jnp.einsum('...j,jk->...k', images, rev_whitening_transform)
images = images.reshape(orig_shape[0], -1)
images = images + zca_mean
images = images.reshape(orig_shape)
if mean is not None:
images = images * std + mean
return images
return preprocess_op, preprocess_op_rev
def get_preprocess_op_tf(resize=False, resolution=None, mean=None, std=None, zca_mean=None, whitening_transform=None,
block_size=None):
# This operation deals with one data per time
def preprocess_op(x):
if resize:
shape = tf.shape(x)
h, w = shape[0], shape[1]
size = tf.minimum(h, w)
begin = tf.cast([h - size, w - size], tf.float32) / 2.0
begin = tf.cast(begin, tf.int32)
begin = tf.concat([begin, [0]], axis=0) # Add channel dimension.
x = tf.slice(x, begin, [size, size, 3])
x = tf.image.resize_with_pad(x, resolution, resolution, method='area', antialias=True)
x = tf.cast(x, dtype='float32')
x = x / 255.0
if mean is not None:
x = (x - mean) / std
if zca_mean is not None:
orig_shape = x.shape
x = tf.reshape(x, shape=(-1,))
x = x - zca_mean
if block_size is not None:
x = blockshaped(x, orig_shape[-3], orig_shape[-2], orig_shape[-1], block_size, block_size, is_tf=True)
x = tf.einsum('...ij,ijk->...ik', x, whitening_transform)
x = unblockshaped(x, orig_shape[-3], orig_shape[-2], orig_shape[-1], block_size, block_size, is_tf=True)
else:
x = tf.einsum('...j,jk->...k', x, whitening_transform)
x = tf.reshape(x, shape=orig_shape)
return x
return preprocess_op
def load_data(ds, img_shape, preprocess_op, resolution=32, batch_size=1000):
size = len(ds)
logging.info('Dataset size: {}'.format(size))
if None in img_shape:
x = np.zeros(shape=(size, resolution, resolution, 3))
else:
x = np.zeros(shape=(size, img_shape[0], img_shape[1], img_shape[2]))
ds = ds.map(lambda x, y: (tf.cast(x, dtype='float32') / 255.0, y), tf.data.AUTOTUNE)
if None in img_shape:
ds = ds.map(lambda x, y: (center_crop(x, resolution), y), tf.data.AUTOTUNE)
ds = ds.batch(batch_size=batch_size)
ds = ds.prefetch(buffer_size=tf.data.AUTOTUNE)
y_list = []
count = 0
for x_batch, y_batch in tqdm.tqdm(tfds.as_numpy(ds), desc='Process the data'):
num = x_batch.shape[0]
x_processed = np.array(preprocess_op(x_batch))
x[count:count + num] = x_processed
y_list.append(y_batch)
count += num
return x, np.concatenate(y_list, axis=0)
def write_tfrecord(ds, filepattern, preprocess_op, features, num_per_shard, num_shard):
count = 0
shard = 0
shard_lengths = []
writer = tf.io.TFRecordWriter(
'{}.tfrecord-{}-of-{}'.format(filepattern, str(shard).zfill(5), str(num_shard).zfill(5)))
for x_batch, y_batch in tqdm.tqdm(tfds.as_numpy(ds), desc='Process the data'):
print(x_batch.shape)
x_processed = np.array(preprocess_op(x_batch), dtype=np.float32)
for i in range(x_processed.shape[0]):
data = {'image': x_processed[i], 'label': y_batch[i]}
writer.write(features.serialize_example(data))
count += 1
if count == num_per_shard:
shard_lengths.append(count)
writer.flush()
writer.close()
count = 0
shard += 1
if shard < num_shard:
writer = tf.io.TFRecordWriter(
'{}.tfrecord-{}-of-{}'.format(filepattern, str(shard).zfill(5), str(num_shard).zfill(5)))
if count != 0:
shard_lengths.append(count)
writer.flush()
writer.close()
return shard_lengths
def process2tfrecord(ds_train, ds_test, data_dir, dataset_name, img_shape_orig, num_classes, preprocess_op, resolution=32,
batch_size=1000, num_per_shard=10000):
print(img_shape_orig)
print(resolution)
def get_ds(ds):
ds = ds.map(lambda x, y: (tf.cast(x, dtype='float32') / 255.0, y), tf.data.AUTOTUNE)
if None in img_shape_orig:
ds = ds.map(lambda x, y: (center_crop(
x, resolution), y), tf.data.AUTOTUNE)
ds = ds.batch(batch_size=batch_size)
ds = ds.prefetch(buffer_size=tf.data.AUTOTUNE)
return ds
if None in img_shape_orig:
img_shape = (resolution, resolution, 3)
else:
img_shape = img_shape_orig
features = tfds.features.FeaturesDict({
'image': tfds.features.Tensor(shape=img_shape, dtype=tf.float32),
'label': tfds.features.ClassLabel(num_classes=num_classes)})
# Process train
size = len(ds_train)
num_shard = size // num_per_shard
if size % num_per_shard != 0:
num_shard += 1
logging.info('Number of examples: {}, num per shard: {}, num shards: {}'.format(
size, num_per_shard, num_shard))
filepattern = '{}/{}-train'.format(data_dir, dataset_name)
shard_lengths_train = write_tfrecord(
get_ds(ds_train), filepattern, preprocess_op, features, num_per_shard, num_shard)
# Process test
size = len(ds_test)
num_shard = size // num_per_shard
if size % num_per_shard != 0:
num_shard += 1
logging.info('Number of examples: {}, num per shard: {}, num shards: {}'.format(
size, num_per_shard, num_shard))
filepattern = '{}/{}-test'.format(data_dir, dataset_name)
shard_lengths_test = write_tfrecord(
get_ds(ds_test), filepattern, preprocess_op, features, num_per_shard, num_shard)
split_infos = [
tfds.core.SplitInfo(
name='train', shard_lengths=shard_lengths_train, num_bytes=0),
tfds.core.SplitInfo(
name='test', shard_lengths=shard_lengths_test, num_bytes=0),
]
tfds.folder_dataset.write_metadata(data_dir=data_dir, features=features, split_infos=split_infos,
supervised_keys=('image', 'label'))
| 18,070 | 39.337054 | 122 | py |
RCIG | RCIG-master/algorithms.py | # import eqm_prop_crap
import torch
import jax
import jax.numpy as jnp
import numpy as np
from flax.training import train_state, checkpoints
import ml_collections
import flax.linen as nn
from typing import Any, Callable, Sequence, Tuple
import jax.scipy as jsp
import functools
import flax
import optax
import utils
import time
from augmax import get_aug_by_name
import copy
from absl import logging
def identity(key, x):
return x
def get_tree_mask(model_depth = 3, has_bn = False, learn_final = False):
mask = {
'Dense_0' : {
'bias': True,
'kernel': learn_final
},
}
for i in range(model_depth):
mask['Conv_{}'.format(i)] = True
if has_bn:
mask['BatchNorm_{}'.format(i)] = True
return mask
@functools.partial(jax.jit, static_argnames=('pool_learning_rate', 'model_depth', 'has_bn', 'linearize', 'net_forward_apply', 'net_forward_init', 'img_shape', 'naive_loss'))
def get_new_train_state(key_inner, pool_learning_rate, model_depth, has_bn, linearize, net_forward_apply, net_forward_init, img_shape, naive_loss = False):
inner_opt = optax.chain(
optax.masked(optax.adam(learning_rate=0.0001), {'base_params': False, 'tangent_params': get_tree_mask(model_depth = model_depth, has_bn = has_bn, learn_final = naive_loss)}),
optax.masked(optax.adam(learning_rate=pool_learning_rate), {'base_params': True, 'tangent_params': False}))
new_params = net_forward_init(key_inner, jnp.zeros(shape = img_shape))
key_inner = jax.random.split(key_inner)[0]
new_batch_stats = new_params['batch_stats'] if has_bn else None
new_params = new_params.unfreeze()
if linearize:
forward_linear = get_linear_forward(net_forward_apply, has_bn = has_bn)
params_dict = {'base_params': new_params['params'], 'tangent_params': utils._zero_like(new_params['params'])}
new_train_state = TrainStateWithBatchStats.create(apply_fn = forward_linear, params = params_dict, tx = inner_opt, batch_stats = new_batch_stats, train_it = 0)
else:
if naive_loss:
new_train_state = TrainStateWithBatchStats.create(apply_fn = net_forward_apply, params = new_params['params'], tx = optax.adam(learning_rate = 0.0001), batch_stats = new_batch_stats, train_it = 0)
else:
forward_linear = get_linear_forward(net_forward_apply, has_bn = has_bn, linearize = False)
params_dict = {'base_params': new_params['params'], 'tangent_params': utils._zero_like(new_params['params'])}
new_train_state = TrainStateWithBatchStats.create(apply_fn = forward_linear, params = params_dict, tx = inner_opt, batch_stats = new_batch_stats, train_it = 0)
return new_train_state, key_inner
def run_rcig(coreset_images_init, coreset_labels_init, net_forward_init, net_forward_apply, train_loader, alg_config, key, inner_learning_rate, hvp_learning_rate, test_fn = None, coreset_train_state = None, pool = None, lr_tune = False, start_iter = 0):
if lr_tune:
#We change some stuff in the config if we are tuning the inner/hessian inverse learning rates
alg_config = copy.deepcopy(alg_config)
alg_config.pool_model_count = 1
alg_config.max_steps = 1
alg_config.monitor_losses = True
alg_config.aug = None
alg_config.aug_repeats = 0
alg_config = ml_collections.FrozenConfigDict(alg_config)
#Instatiate model pool
if pool is None:
model_pool = []
for m in range(alg_config.pool_model_count):
new_train_state, key = get_new_train_state(key, alg_config.pool_learning_rate, alg_config.model_depth, alg_config.has_bn, alg_config.linearize, net_forward_apply, net_forward_init, coreset_images_init.shape, naive_loss = alg_config.naive_loss)
model_pool.append(jax.device_put(new_train_state, jax.devices('cpu')[0]))
else:
model_pool = pool
if coreset_train_state is None:
proto_obj = ProtoHolder(coreset_images_init, coreset_labels_init, 0.0, coreset_images_init.shape[0], learn_label=alg_config.learn_labels, use_flip = alg_config.use_flip)
lr_schedule = alg_config.proto_learning_rate
coreset_opt = optax.chain(
optax.masked(optax.adabelief(learning_rate=lr_schedule), {'x_proto': True, 'y_proto': True, 'log_temp': False}),
optax.masked(optax.adabelief(learning_rate=0.03), {'x_proto': False, 'y_proto': False, 'log_temp': True}),
)
coreset_init_params = proto_obj.init({'params': key}).unfreeze()['params']
coreset_train_state = CoresetTrainState.create(apply_fn = proto_obj.apply, tx = coreset_opt, params = coreset_init_params, train_it = 0, ema_average = coreset_init_params, ema_hidden = utils._zero_like(coreset_init_params))
n_steps = 0
aug = identity if alg_config.aug is None else get_aug_by_name(alg_config.aug, alg_config.img_size)
print(alg_config.aug)
inner_lr_stats = []
hvp_lr_stats = []
lr_monitor_interval = 50
start_time = time.time()
if start_iter == 0 and not lr_tune and alg_config.output_dir is not None:
logging.info(f'Saving checkpoint at iter 0 at time {time.time() - start_time}')
checkpoints.save_checkpoint(ckpt_dir = './{}/'.format(alg_config.output_dir), target = coreset_train_state, step = 0, keep = 1e10)
while(n_steps < alg_config.max_steps):
for train_images, train_labels in train_loader.as_numpy_iterator():
debug_info = [n_steps]
model_index = jax.random.randint(key, (), 0, alg_config.pool_model_count)
key = jax.random.split(key)[0]
#Select Model state
selected_model_state = jax.device_put(model_pool[model_index], jax.devices('gpu')[0])
#Do inner steps
n_steps_to_opt = alg_config.n_inner_steps
key, train_key = jax.random.split(key)
x_proto, y_proto, _ = coreset_train_state.apply_fn({'params': coreset_train_state.params})
coreset_batch = {'images': x_proto, 'labels': y_proto}
new_train_state, losses = do_training_steps(selected_model_state, coreset_batch, train_key, n_steps = n_steps_to_opt, l2 = alg_config.l2, has_bn = alg_config.has_bn, train = False, aug = aug, do_krr = not alg_config.naive_loss, batch_size = alg_config.inner_train_batch_size, inject_lr = inner_learning_rate, alg_config = alg_config)
if alg_config.monitor_losses:
print(losses[:20])
#This is all stuff for making sure our learning rates aren't too high. TL;DR if we notice that the inner losses are often diverging, we decrease the learning rate, and we slightly increase if they are all monotonically decreasing
loss_diag = (losses[:alg_config.n_inner_steps] - jnp.roll(losses[:alg_config.n_inner_steps], -1))
if alg_config.n_inner_steps == 0:
inner_lr_stats.append(0)
elif jnp.all(loss_diag[:-1] > 0):
# print("monotonic")
inner_lr_stats.append(1)
elif jnp.all(loss_diag[-1] > 0):
# print('fail')
inner_lr_stats.append(-1)
# print("HALVING")
else:
# print('unstable')
inner_lr_stats.append(0)
debug_info.append(inner_learning_rate)
debug_info.append(inner_lr_stats[-1])
debug_info.append(float(losses[0]))
debug_info.append(float(losses[alg_config.n_inner_steps - 1]))
if alg_config.n_inner_steps > 0:
debug_info.append(float(losses[alg_config.n_inner_steps - 1])/float(losses[0]))
else:
debug_info.append(0)
if n_steps%lr_monitor_interval == 0 and n_steps > 0:
if jnp.mean(np.array(inner_lr_stats) == -1) >= .29:
# print("FAILING DECREASE")
#more than 30% fail, shoudl decrease learning rate
inner_learning_rate *= 0.9
elif jnp.mean(np.array(inner_lr_stats) == 1) >= .7:
#more than 95% monotonic decrease, can increase the learning rate
# print("STABLE INCREASING")
inner_learning_rate *= 1.05
inner_lr_stats = []
#Comput the implicit gradient
key, meta_train_key = jax.random.split(key)
coreset_train_state, (outer_loss, outer_acc, residuals, grad_norm, update_norms, update_maxes, norm_ratios) = do_meta_train_step(new_train_state, coreset_train_state, train_images, train_labels, has_bn = alg_config.has_bn, l2 = alg_config.l2,
n_hinv_steps = alg_config.n_hinv_steps, do_krr = not alg_config.naive_loss, aug = aug, aug_repeats = alg_config.aug_repeats, aug_key = meta_train_key,
lr = hvp_learning_rate, normal_repeats = alg_config.normal_repeats,
direct_batch_sizes = alg_config.direct_batch_sizes, implicit_batch_size = alg_config.implicit_batch_size,
hinv_batch_size = alg_config.hinv_batch_size, do_precompute = alg_config.do_precompute, max_forward_batch_size = alg_config.max_forward_batch_size, alg_config = alg_config)
if alg_config.monitor_losses:
print(residuals[:20])
#Again more logging/debug stuff for making sure our hessian inverse computation isn't diverging
loss_diag = (residuals[:alg_config.n_hinv_steps] - jnp.roll(residuals[:alg_config.n_hinv_steps], -1))
if alg_config.n_hinv_steps == 0:
hvp_lr_stats.append(0)
elif jnp.all(loss_diag[:-1] > 0):
# print("monotonic")
hvp_lr_stats.append(1)
elif jnp.all(loss_diag[-1] > 0):
# print('fail')
hvp_lr_stats.append(-1)
# print("HALVING")
else:
# print('unstable')
hvp_lr_stats.append(0)
debug_info.append(hvp_learning_rate)
debug_info.append(hvp_lr_stats[-1])
debug_info.append(grad_norm)
debug_info.append(update_norms)
debug_info.append(update_maxes)
debug_info.append(norm_ratios)
print(f'iter: {n_steps + 1}, outer loss: {outer_loss}, outer acc: {outer_acc}')
debug_info.append(float(outer_loss))
debug_info.append(float(outer_acc))
logging.info(debug_info)
#Do training steps for the pool models
key, outer_train_key = jax.random.split(key)
n_steps_to_opt_pool = jax.random.randint(key, (), 1, alg_config.n_max_steps_pool)
x_proto, y_proto, _ = coreset_train_state.apply_fn({'params': coreset_train_state.params})
coreset_batch = {'images': x_proto, 'labels': y_proto}
model_pool[model_index], outer_loss = do_training_steps(selected_model_state, coreset_batch, outer_train_key, n_steps = n_steps_to_opt_pool, has_bn = alg_config.has_bn, use_base_params = not alg_config.naive_loss, aug = aug, batch_size = alg_config.pool_train_batch_size, max_batch_size = coreset_train_state.params['x_proto'].shape[0], train = True)
model_pool[model_index] = jax.device_put(model_pool[model_index], jax.devices('cpu')[0])
#create new pool model if it has done too many training steps
if model_pool[model_index].train_it >= alg_config.max_online_steps:
new_train_state, key = get_new_train_state(key, alg_config.pool_learning_rate, alg_config.model_depth, alg_config.has_bn, alg_config.linearize, net_forward_apply, net_forward_init, coreset_images_init.shape, naive_loss = alg_config.naive_loss)
model_pool[model_index] = jax.device_put(new_train_state, jax.devices('cpu')[0])
n_steps += 1
#checkpoint saving
if start_iter + n_steps in alg_config.checkpoint_iters and not lr_tune and n_steps != 0 and alg_config.output_dir is not None:
print(f"saving at iter {n_steps + start_iter} at time {time.time() - start_time}")
logging.info(f'Saving checkpoint at iter {n_steps + start_iter} at time {time.time() - start_time}')
checkpoints.save_checkpoint(ckpt_dir = './{}/'.format(alg_config.output_dir), target = coreset_train_state, step = n_steps + start_iter, keep = 1e10)
if n_steps >= alg_config.max_steps:
break
# return coreset_train_state.params['x_proto']
if lr_tune:
return inner_lr_stats[0], hvp_lr_stats[0]
return coreset_train_state, key, model_pool, inner_learning_rate, hvp_learning_rate
@functools.partial(jax.jit, static_argnames=('has_bn', 'do_krr', 'aug', 'aug_repeats', 'batch_sizes', 'normal_repeats', 'max_forward_batch_size'))
def get_gt_and_direct(model_train_state, coreset_train_state, train_images, train_labels, has_bn = False, l2 = 0., n_hinv_steps = 20, cg_init = None, do_krr = False, aug = None, aug_repeats = 0, aug_key = None, normal_repeats = 1, batch_sizes = None, pre_s = None, pre_t = None, pre_s_aug = None, max_forward_batch_size = None):
if has_bn:
batch_stats = model_train_state.batch_stats
else:
batch_stats = None
if not do_krr:
(loss, (_, acc, _)), g_t = jax.value_and_grad(get_training_loss_l2, argnums = 0, has_aux = True)(model_train_state.params, train_images, train_labels, model_train_state, l2 = 0, train = False, has_bn = has_bn, batch_stats = batch_stats)
direct_grad = utils._zero_like(coreset_train_state.params)
else:
@functools.partial(jax.jit, static_argnames=('batch_aug'))
def body_fn(i, val, batch_aug = identity):
g_t_cum, direct_grad_cum, loss, acc, key, pre_s_inner = val
key, aug_key, grad_key1, grad_key2 = jax.random.split(key, 4)
#This (and any mention about grad indices) has to do with randomly sampling samples to backpropagate through. It's only relevant for bigger coreset sizes
if batch_sizes[0] is not None:
grad_indices1 = jax.random.choice(grad_key1, coreset_train_state.apply_fn({'params': coreset_train_state.params})[0].shape[0], shape = [batch_sizes[0]], replace = False)
else:
grad_indices1 = None
if batch_sizes[1] is not None:
grad_indices2 = jax.random.choice(grad_key2, train_images.shape[0], shape = [batch_sizes[1]], replace = False)
else:
grad_indices2 = None
(loss, (acc, _)), (g_t, direct_grad) = jax.value_and_grad(get_krr_loss, argnums = (0,1), has_aux = True)(model_train_state.params, coreset_train_state.params, coreset_train_state.apply_fn, train_images, train_labels, model_train_state.apply_fn, has_bn = has_bn, batch_stats = batch_stats, l2 = l2, grad_indices1 = grad_indices1, grad_indices2 = grad_indices2, aug = batch_aug, pre_s = pre_s_inner, pre_t = pre_t, max_forward_batch_size = max_forward_batch_size)
g_t_cum = utils._add(g_t_cum, g_t)
direct_grad_cum = utils._add(direct_grad_cum, direct_grad)
return (g_t_cum, direct_grad_cum, loss, acc, key, pre_s_inner)
g_t, direct_grad, loss, acc, aug_key, _ = jax.lax.fori_loop(0, normal_repeats, body_fn, (utils._sub(model_train_state.params, model_train_state.params), utils._sub(coreset_train_state.params, coreset_train_state.params), 0,0, aug_key, pre_s))
g_t_aug, direct_grad_aug, _, _, aug_key, _ = jax.lax.fori_loop(0, aug_repeats, utils.bind(body_fn, ...,..., aug), (utils._sub(model_train_state.params, model_train_state.params), utils._sub(coreset_train_state.params, coreset_train_state.params), 0,0, aug_key, pre_s_aug))
direct_grad = utils._add(direct_grad, direct_grad_aug)
g_t = utils._add(g_t, g_t_aug)
direct_grad = multiply_by_scalar(direct_grad, 1/(aug_repeats + normal_repeats))
g_t = multiply_by_scalar(g_t, 1/(aug_repeats + normal_repeats))
return g_t, direct_grad, aug_key, loss, acc
@functools.partial(jax.jit, static_argnames=('has_bn', 'do_krr', 'aug', 'aug_repeats', 'normal_repeats', 'batch_size', 'use_x64'))
def get_implicit_grad(h_inv_vp, model_train_state, coreset_train_state, train_images, train_labels, has_bn = False, l2 = 0., n_hinv_steps = 20, cg_init = None, do_krr = False, aug = None, aug_repeats = 0, aug_key = None, normal_repeats = 1, batch_size = None, pre_s = None, pre_s_aug = None, use_x64 = False):
if has_bn:
batch_stats = model_train_state.batch_stats
else:
batch_stats = None
def cg_shit(coreset_train_state_params_inner, aug_inner, key_inner, pre_s_inner):
# h_inv_vp, hists = get_v_h_inv_approx(params, coreset_images, coreset_labels, net_forward_apply, g_t, n_iters = 20)
images_inner, labels_inner, log_temp = coreset_train_state.apply_fn({'params': coreset_train_state_params_inner})
aug_key, index_key = jax.random.split(key_inner)
aug_images = aug_inner(aug_key, images_inner)
if batch_size is not None:
grad_indices = jax.random.choice(index_key, aug_images.shape[0], shape = [batch_size], replace = False)
else:
grad_indices = None
if not do_krr:
g_s = jax.grad(get_training_loss_l2, argnums = 0, has_aux = True)(model_train_state.params, aug_images, labels_inner, model_train_state, l2 = l2, has_bn = has_bn, batch_stats = model_train_state.batch_stats)[0]
return -1 * get_dot_product(h_inv_vp, g_s), g_s
else:
g_s = jax.grad(get_krr_loss_gd, argnums = 0, has_aux = True)(model_train_state.params, model_train_state, aug_images, labels_inner, None, None, l2 = l2, has_bn = has_bn, batch_stats = batch_stats, self_loss = True, log_temp = log_temp, grad_indices = grad_indices, pre_s = pre_s_inner, use_x64 = use_x64)[0]
return -1 * get_dot_product(h_inv_vp, g_s), g_s
@functools.partial(jax.jit, static_argnames=('batch_aug'))
def body_fn(i, val, batch_aug = identity):
implicit_grad_cum, key, pre_s_inner = val
implicit_grad, _ = jax.grad(cg_shit, argnums = 0, has_aux = True)(coreset_train_state.params, batch_aug, key, pre_s_inner)
implicit_grad_cum = utils._add(implicit_grad_cum, implicit_grad)
key = jax.random.split(key, 2)[0]
return (implicit_grad_cum, key, pre_s_inner)
implicit_grad, aug_key,_ = jax.lax.fori_loop(0, normal_repeats, body_fn, (utils._sub(coreset_train_state.params, coreset_train_state.params), aug_key, pre_s))
implicit_grad_aug, aug_key, _ = jax.lax.fori_loop(0, aug_repeats, utils.bind(body_fn, ...,..., aug), (utils._sub(coreset_train_state.params, coreset_train_state.params), aug_key, pre_s_aug))
implicit_grad = utils._add(implicit_grad, implicit_grad_aug)
implicit_grad = multiply_by_scalar(implicit_grad, 1/(aug_repeats + normal_repeats))
return implicit_grad
@functools.partial(jax.jit, static_argnames=('has_bn', 'do_krr', 'aug', 'aug_repeats', 'direct_batch_sizes', 'implicit_batch_size', 'normal_repeats', 'do_precompute', 'hinv_batch_size', 'max_forward_batch_size', 'alg_config'))
def do_meta_train_step(model_train_state, coreset_train_state, train_images, train_labels, has_bn = False, l2 = 0., n_hinv_steps = 20, cg_init = None, do_krr = False, aug = None, aug_repeats = 0, aug_key = None, lr = 3., normal_repeats = 1, direct_batch_sizes = None, implicit_batch_size = None, do_precompute = False, hinv_batch_size = None, max_forward_batch_size = None, alg_config = None):
if has_bn:
batch_stats = model_train_state.batch_stats
else:
batch_stats = None
if do_precompute:
pre_s, pre_t = jax.lax.stop_gradient(get_krr_loss(model_train_state.params, coreset_train_state.params, coreset_train_state.apply_fn, train_images, train_labels, model_train_state.apply_fn, has_bn = has_bn, batch_stats = batch_stats, l2 = l2, aug = identity, do_precompute = True, max_forward_batch_size = max_forward_batch_size, use_x64 = alg_config.use_x64))
aug_key, precompute_key = jax.random.split(aug_key)
pre_s_aug, _ = jax.lax.stop_gradient(get_krr_loss(model_train_state.params, coreset_train_state.params, coreset_train_state.apply_fn, train_images, train_labels, model_train_state.apply_fn, has_bn = has_bn, batch_stats = batch_stats, l2 = l2, aug = aug, do_precompute = True, aug_key = precompute_key, max_forward_batch_size = max_forward_batch_size, use_x64 = alg_config.use_x64))
else:
pre_s, pre_t, pre_s_aug = None, None, None
g_t, direct_grad, aug_key, loss, acc = jax.lax.stop_gradient(get_gt_and_direct(model_train_state, coreset_train_state, train_images, train_labels, has_bn = has_bn, l2 = l2, n_hinv_steps = n_hinv_steps, cg_init = cg_init, do_krr = do_krr, aug = aug, aug_repeats = aug_repeats, aug_key = aug_key, normal_repeats = normal_repeats, batch_sizes = direct_batch_sizes, pre_s = pre_s, pre_s_aug = pre_s_aug, pre_t = pre_t, max_forward_batch_size = max_forward_batch_size))
if aug is not None and do_precompute:
h_inv_vp, residuals = jax.lax.stop_gradient(get_h_inv_vp(coreset_train_state, model_train_state, g_t, n_steps = n_hinv_steps, l2 = l2, has_bn = has_bn, batch_stats = batch_stats, init = cg_init, do_krr = do_krr, lr = lr, pre_s = pre_s_aug, batch_size = hinv_batch_size, alg_config = alg_config))
else:
h_inv_vp, residuals = jax.lax.stop_gradient(get_h_inv_vp(coreset_train_state, model_train_state, g_t, n_steps = n_hinv_steps, l2 = l2, has_bn = has_bn, batch_stats = batch_stats, init = cg_init, do_krr = do_krr, lr = lr, pre_s = pre_s, batch_size = hinv_batch_size, alg_config = alg_config))
implicit_grad = get_implicit_grad(h_inv_vp, model_train_state, coreset_train_state, train_images, train_labels, has_bn = has_bn, l2 = l2, n_hinv_steps = n_hinv_steps, cg_init = cg_init, do_krr = do_krr, aug = aug, aug_repeats = aug_repeats, aug_key = aug_key, normal_repeats = normal_repeats, batch_size = implicit_batch_size, pre_s = pre_s, pre_s_aug = pre_s_aug, use_x64 = alg_config.use_x64)
#clip implicit gradient norm so it isn't larger than the direct gradient norm
#we found that this helps stability for high resolution datasets, as the implicit gradient could grow very very large
clip = not alg_config.naive_loss
if clip:
igrad_norm = jax.tree_map(jnp.linalg.norm, implicit_grad)
dgrad_norm = jax.tree_map(jnp.linalg.norm, direct_grad)
max_norm_tree = jax.tree_map(jnp.minimum, dgrad_norm, igrad_norm)
implicit_grad = jax.tree_map(lambda g, g_norm, max_norm: (g/g_norm) * max_norm, implicit_grad, igrad_norm, max_norm_tree)
implicit_grad = jax.tree_map(jnp.nan_to_num, implicit_grad)
norm_ratios = utils._divide(jax.tree_map(jnp.linalg.norm, direct_grad), jax.tree_map(jnp.linalg.norm, implicit_grad))
grad = utils._add(direct_grad, implicit_grad)
coreset_train_state, updates = coreset_train_state.apply_gradients_get_updates(grads = grad, train_it = coreset_train_state.train_it + 1)
new_ema_hidden, new_ema_average = get_updated_ema(coreset_train_state.params, coreset_train_state.ema_hidden, 0.99, coreset_train_state.train_it, order = 1)
coreset_train_state = coreset_train_state.replace(ema_average = new_ema_average, ema_hidden = new_ema_hidden)
return coreset_train_state, (loss, acc, residuals, jax.tree_map(jnp.linalg.norm, grad), jax.tree_map(jnp.linalg.norm, updates), jax.tree_map(jnp.max, jax.tree_map(jnp.abs, updates)), norm_ratios)
@functools.partial(jax.jit, static_argnames=('has_bn', 'other_opt', 'do_krr', 'aug', 'batch_size', 'alg_config'))
def get_h_inv_vp(coreset_train_state, model_train_state, g_t, n_steps = 20, l2 = 0.0, has_bn = False, batch_stats = None, other_opt = False, init = None, do_krr = False, aug = identity, aug_key = jax.random.PRNGKey(0), lr = 3., pre_s = None, batch_size = None, alg_config = None):
opt_init, opt_update = optax.chain(optax.adam(lr))
residuals = jnp.zeros(1000)
if init is None:
x = utils._zero_like(g_t)
else:
x = init
opt_state = opt_init(x)
def body_fn(i, val):
x, opt_state, residuals, aug_key = val
x_proto, y_proto, _ = coreset_train_state.apply_fn({'params': coreset_train_state.params})
if not do_krr:
Hx = get_training_loss_hvp(model_train_state.params, x_proto, y_proto, model_train_state, x, l2 = l2, has_bn = has_bn, batch_stats = model_train_state.batch_stats)
else:
aug_key, grad_key = jax.random.split(aug_key)
aug_images = aug(aug_key, x_proto)
if batch_size is None:
grad_indices = None
else:
grad_indices = jax.random.choice(grad_key, aug_images.shape[0], shape = [batch_size], replace = False)
Hx = get_training_loss_hvp_krr(model_train_state.params, aug_images, y_proto, model_train_state, x, l2 = l2, has_bn = has_bn, batch_stats = model_train_state.batch_stats, grad_indices = grad_indices, pre_s = pre_s, alg_config = alg_config)
grad = utils._sub(Hx, g_t)
residual = get_dot_product(x, utils._sub(Hx, multiply_by_scalar(g_t, 2)))
updates, new_opt_state = opt_update(grad, opt_state, x)
x = optax.apply_updates(x, updates)
residuals = residuals.at[i].set(residual)
return x, new_opt_state, residuals, aug_key
h_inv_vp, _, residuals, _ = jax.lax.fori_loop(0, n_steps, body_fn, (x, opt_state, residuals, aug_key))
return h_inv_vp, residuals
def invert_grad_indices(grad_indices, max_size):
grad_mask = jnp.zeros(shape = [max_size], dtype = jnp.bool_).at[grad_indices].set(True)
return jnp.nonzero(~grad_mask, size = max_size - grad_indices.shape[0])
@functools.partial(jax.jit, static_argnames=('train', 'has_bn', 'net_forward_apply', 'coreset_train_state_apply', 'aug', 'do_precompute', 'max_forward_batch_size', 'use_x64'))
def get_krr_loss(params, coreset_train_state_params, coreset_train_state_apply, images2, labels2, net_forward_apply, has_bn = True, batch_stats = None, l2 = 0., aug = None, aug_key = jax.random.PRNGKey(0), grad_indices1 = None, grad_indices2 = None, do_precompute = False, pre_s = None, pre_t = None, max_forward_batch_size = None, use_x64 = False):
images, labels, log_temp = coreset_train_state_apply({'params': coreset_train_state_params})
if aug is not None:
images = aug(aug_key, images)
if has_bn:
net_variables = {'params': params, 'batch_stats': batch_stats}
else:
net_variables = {'params': params}
if do_precompute:
feat_s, out_s = batch_precompute(net_forward_apply, net_variables, images, max_forward_batch_size = max_forward_batch_size)
elif pre_s is not None and grad_indices1 is not None:
inv_grad_indices = invert_grad_indices(grad_indices1, images.shape[0])
(_, feat_s1), (out_s1, _), _ = net_forward_apply(net_variables, images[grad_indices1], features = True, train = False, mutable=['batch_stats'], return_all = True)
feat_s2 = pre_s[0][inv_grad_indices]
out_s2 = pre_s[1][inv_grad_indices]
grad_labels = labels[grad_indices1]
no_grad_labels = labels[inv_grad_indices]
labels = jnp.concatenate([grad_labels, no_grad_labels])
feat_s = jnp.concatenate([feat_s1, feat_s2])
out_s = jnp.concatenate([out_s1, out_s2])
elif grad_indices1 is not None:
inv_grad_indices = invert_grad_indices(grad_indices1, images.shape[0])
(_, feat_s1), (out_s1, _), _ = net_forward_apply(net_variables, images[grad_indices1], features = True, train = False, mutable=['batch_stats'], return_all = True)
feat_s2, out_s2 = batch_precompute(net_forward_apply, net_variables, images[inv_grad_indices], max_forward_batch_size = max_forward_batch_size)
grad_labels = labels[grad_indices1]
no_grad_labels = labels[inv_grad_indices]
labels = jnp.concatenate([grad_labels, no_grad_labels])
feat_s = jnp.concatenate([feat_s1, feat_s2])
out_s = jnp.concatenate([out_s1, out_s2])
else:
(_, feat_s), (out_s, _), _ = net_forward_apply(net_variables, images, features = True, train = False, mutable=['batch_stats'], return_all = True)
if do_precompute:
feat_t, out_t = batch_precompute(net_forward_apply, net_variables, images2, max_forward_batch_size = max_forward_batch_size)
elif pre_t is not None and grad_indices2 is not None:
inv_grad_indices = invert_grad_indices(grad_indices2, images2.shape[0])
(_, feat_t1), (out_t1, _), _ = net_forward_apply(net_variables, images2[grad_indices2], features = True, train = False, mutable=['batch_stats'], return_all = True)
feat_t2 = pre_t[0][inv_grad_indices]
out_t2 = pre_t[1][inv_grad_indices]
grad_labels2 = labels2[grad_indices2]
no_grad_labels2 = labels2[inv_grad_indices]
labels2 = jnp.concatenate([grad_labels2, no_grad_labels2])
feat_t = jnp.concatenate([feat_t1, feat_t2])
out_t = jnp.concatenate([out_t1, out_t2])
elif grad_indices2 is not None:
inv_grad_indices = invert_grad_indices(grad_indices2, images2.shape[0])
(_, feat_t1), (out_t1, _), _ = net_forward_apply(net_variables, images2[grad_indices2], features = True, train = False, mutable=['batch_stats'], return_all = True)
feat_t2, out_t2 = batch_precompute(net_forward_apply, net_variables, images2[inv_grad_indices], max_forward_batch_size = max_forward_batch_size)
grad_labels2 = labels2[grad_indices2]
no_grad_labels2 = labels2[inv_grad_indices]
labels2 = jnp.concatenate([grad_labels2, no_grad_labels2])
feat_t = jnp.concatenate([feat_t1, feat_t2])
out_t = jnp.concatenate([out_t1, out_t2])
else:
(_, feat_t), (out_t, _), _ = net_forward_apply(net_variables, images2, features = True, train = False, mutable=['batch_stats'], return_all = True)
if do_precompute:
return (feat_s, out_s), (feat_t, out_t)
if use_x64:
K_ss = (feat_s @ feat_s.T).astype(jnp.float64)
else:
K_ss = feat_s @ feat_s.T
K_ts = feat_t @ feat_s.T
K_ss_reg = K_ss + l2 * jnp.eye(K_ss.shape[0])
preds = out_t + K_ts @ jnp.linalg.solve(K_ss_reg, labels - out_s)
y_hat = labels2
acc = jnp.mean(preds.argmax(1) == labels2.argmax(1))
loss = 0.5 * jnp.mean((preds - y_hat)**2)
labels2_oh = labels2 - jnp.min(labels2)
loss = jnp.mean(optax.softmax_cross_entropy(preds * jnp.exp(log_temp), labels2_oh))
dim = labels.shape[-1]
val, idx = jax.lax.top_k(labels, k=2)
margin = jnp.minimum(val[:, 0] - val[:, 1], 1 /(2 * dim))
#small loss so that the top label stays at least 1/(2c) higher than the next label
#we are unsure if this actually does anything useful but we had it in the code when we ran the experiments
#it is quite likely it makes no difference
return loss.astype(jnp.float32) - margin.mean(), (acc, 0)
@functools.partial(jax.jit, static_argnames=('apply_fn', 'max_forward_batch_size'))
def batch_precompute(apply_fn, variables, images, max_forward_batch_size = None):
if max_forward_batch_size is None or max_forward_batch_size >= images.shape[0]:
(_, feat), (out, _), _ = jax.lax.stop_gradient(apply_fn(variables, images, features = True, train = False, mutable=['batch_stats'], return_all = True))
return feat, out
else:
def body_fn(carry, t):
i = carry
batch_images = jax.lax.stop_gradient(jax.lax.dynamic_slice(images, (i * max_forward_batch_size, 0, 0, 0), (max_forward_batch_size, images.shape[1], images.shape[2], images.shape[3])))
(_, feat), (out, _), _ = jax.lax.stop_gradient(apply_fn(variables, batch_images, features = True, train = False, mutable=['batch_stats'], return_all = True))
return i+1, jax.lax.stop_gradient([feat, out])
_, [feats, outs] = jax.lax.scan(body_fn, 0, jnp.arange((images.shape[0] - 1)//max_forward_batch_size))
final_batch_size = ((images.shape[0] - 1) % max_forward_batch_size) + 1
(_, feat), (out, _), _ = jax.lax.stop_gradient(apply_fn(variables, images[images.shape[0]-final_batch_size:], features = True, train = False, mutable=['batch_stats'], return_all = True))
feats, outs = jnp.concatenate([feats.reshape(-1, feats.shape[-1]), feat]), jnp.concatenate([outs.reshape(-1, outs.shape[-1]), out])
return feats, outs
@functools.partial(jax.jit, static_argnames=('train', 'has_bn', 'self_loss', 'use_base_params', 'max_forward_batch_size', 'use_x64'))
def get_krr_loss_gd(params, net_train_state, images, labels, images2, labels2, has_bn = True, batch_stats = None, l2 = 0., self_loss = True, use_base_params = False, log_temp = 0., grad_indices = None, pre_s = None, max_forward_batch_size = None, use_x64 = False):
if has_bn:
net_variables = {'params': params, 'batch_stats': batch_stats}
else:
net_variables = {'params': params}
if pre_s is not None and grad_indices is not None:
inv_grad_indices = invert_grad_indices(grad_indices, images.shape[0])
(_, feat_s1), (out_s1, _), _ = net_train_state.apply_fn(net_variables, images[grad_indices], features = True, train = False, mutable=['batch_stats'], return_all = True)
feat_s2 = pre_s[0][inv_grad_indices]
out_s2 = pre_s[1][inv_grad_indices]
grad_labels = labels[grad_indices]
no_grad_labels = labels[inv_grad_indices]
labels = jnp.concatenate([grad_labels, no_grad_labels])
feat_s = jnp.concatenate([feat_s1, feat_s2])
out_s = jnp.concatenate([out_s1, out_s2])
elif grad_indices is not None:
inv_grad_indices = invert_grad_indices(grad_indices, images.shape[0])
(_, feat_s1), (out_s1, _), _ = net_train_state.apply_fn(net_variables, images[grad_indices], features = True, train = False, mutable=['batch_stats'], return_all = True)
feat_s2, out_s2 = batch_precompute(net_train_state.apply_fn, net_variables, images[inv_grad_indices], max_forward_batch_size = max_forward_batch_size)
grad_labels = labels[grad_indices]
no_grad_labels = labels[inv_grad_indices]
labels = jnp.concatenate([grad_labels, no_grad_labels])
feat_s = jnp.concatenate([feat_s1, feat_s2])
out_s = jnp.concatenate([out_s1, out_s2])
else:
(_, feat_s), (out_s, _), _ = net_train_state.apply_fn(net_variables, images, features = True, train = False, mutable=['batch_stats'], return_all = True)
if use_x64:
K_ss = (feat_s @ feat_s.T).astype(jnp.float64)
else:
K_ss = feat_s @ feat_s.T
if not self_loss:
(_, feat_t), (out_t, _), _ = net_train_state.apply_fn(net_variables, images2, features = True, train = False, mutable=['batch_stats'], return_all = True)
K_ts = feat_t @ feat_s.T
K_ss_reg = K_ss + l2 * jnp.eye(K_ss.shape[0])
spectral_weights = (jnp.linalg.solve(K_ss_reg, labels - out_s))
if self_loss:
preds = out_s + K_ss @ spectral_weights
wtw = (spectral_weights.T @ K_ss @ spectral_weights)
self_err = labels - preds
loss = 0.5 * jnp.trace(self_err @ self_err.T)
added_body = params['tangent_params']
weight_decay_loss = 0.5 * l2 * (jnp.trace(wtw) + get_dot_product(added_body, added_body))
loss += weight_decay_loss
loss = loss/(labels.shape[0] * labels.shape[1])
return loss.astype(jnp.float32), (batch_stats, 1, None)
else:
preds = out_t + K_ts @ spectral_weights
err = labels2 - preds
loss = 0.5 * jnp.mean(err**2)
labels2_oh = labels2 - jnp.min(labels2)
loss = jnp.mean(optax.softmax_cross_entropy(preds * jnp.exp(log_temp), labels2_oh))
acc = jnp.mean(preds.argmax(1) == labels2.argmax(1))
return loss.astype(jnp.float32), (batch_stats, acc, None)
@functools.partial(jax.jit, static_argnames=('train', 'has_bn', 'use_base_params', 'centering'))
def get_training_loss_l2(params, images, labels, net_train_state, l2 = 0., train = False, has_bn = False, batch_stats = None, use_base_params = False, centering = False, init_params = None, init_batch_params = None):
if has_bn:
variables = {'params': params, 'batch_stats': batch_stats}
else:
variables = {'params': params}
mutable = ['batch_stats'] if train else []
if centering:
if has_bn:
init_variables = {'params': init_params, 'batch_stats': init_batch_params}
else:
init_variables = {'params': init_params}
if use_base_params:
outputs, new_batch_stats = net_train_state.apply_fn(variables, images, train = train, mutable=mutable, use_base_params = use_base_params)
else:
outputs, new_batch_stats = net_train_state.apply_fn(variables, images, train = train, mutable=mutable)
if centering:
outputs_init, _ = net_train_state.apply_fn(init_variables, images, train = train, mutable=mutable)
outputs = outputs - outputs_init
loss = jnp.sum(0.5 * (outputs - labels)**2)
if type(l2) is dict:
loss += 0.5 * l2['body'] * get_dot_product(params, params)
else:
if 'base_params' in params:
loss += 0.5 * l2 * get_dot_product(params['tangent_params'], params['tangent_params'])
else:
loss += 0.5 * l2 * get_dot_product(params, params)
acc = jnp.mean(outputs.argmax(1) == labels.argmax(1))
n_correct = jnp.sum(outputs.argmax(1) == labels.argmax(1))
loss = loss/(labels.shape[0] * labels.shape[1])
if has_bn and train:
new_batch_stats = new_batch_stats['batch_stats']
return loss, [new_batch_stats, acc, n_correct]
@functools.partial(jax.jit, static_argnames=('has_bn', 'train', 'update_ema', 'aug', 'use_base_params', 'do_krr', 'centering', 'max_batch_size', 'batch_size', 'alg_config'))
def do_training_steps(train_state, training_batch, key, n_steps = 100, l2 = 0., has_bn = False, train = True, update_ema = False, ema_decay = 0.995, aug = identity, training_batch2 = None, use_base_params = False, do_krr = False, centering = False, init_params = None, init_batch_params = None, batch_size = None, max_batch_size = None, inject_lr = None, alg_config = None):
losses = jnp.zeros(1000)
if inject_lr is not None:
if not alg_config.naive_loss:
train_state = train_state.replace(tx = optax.chain(
optax.masked(optax.adam(learning_rate=inject_lr), {'base_params': False, 'tangent_params': get_tree_mask(model_depth = alg_config.model_depth, has_bn = has_bn, learn_final = alg_config.naive_loss)}),
optax.masked(optax.adam(learning_rate=alg_config.pool_learning_rate), {'base_params': True, 'tangent_params': False})))
else:
train_state = train_state.replace(tx = optax.adam(learning_rate=inject_lr))
def body_fn(i, val):
train_state, losses, key = val
if do_krr:
aug_images = aug(key, training_batch['images'])
batch_labels = training_batch['labels']
if batch_size is None:
grad_indices = None
else:
grad_indices = jax.random.choice(key, aug_images.shape[0], shape = [batch_size], replace = False)
new_train_state, loss = do_training_step_krr(train_state, {'images': aug_images, 'labels': batch_labels}, l2 = l2, has_bn = has_bn, train = train, update_ema = update_ema, ema_decay = ema_decay, grad_indices = grad_indices, max_forward_batch_size = alg_config.max_forward_batch_size, use_x64 = alg_config.use_x64)
else:
if batch_size is None:
aug_images = aug(key, training_batch['images'])
batch_labels = training_batch['labels']
else:
key, aug_key, batch_key = jax.random.split(key, 3)
batch_indices = jax.random.choice(batch_key, max_batch_size, shape = [batch_size], replace = False)
aug_images = aug(aug_key, training_batch['images'][batch_indices])
batch_labels = training_batch['labels'][batch_indices]
new_train_state, loss = do_training_step(train_state, {'images': aug_images, 'labels': batch_labels}, l2 = l2, has_bn = has_bn, train = train, update_ema = update_ema, ema_decay = ema_decay, use_base_params = use_base_params, centering = centering, init_params = init_params, init_batch_params = init_batch_params)
new_losses = losses.at[i].set(loss)
key = jax.random.split(key)[0]
return new_train_state, new_losses, key
train_state, losses, _ = jax.lax.fori_loop(0, n_steps, body_fn, (train_state, losses, key))
return train_state, losses
@functools.partial(jax.jit, static_argnames=('has_bn', 'train', 'update_ema', 'use_base_params', 'centering'))
def do_training_step(train_state, training_batch, l2 = 0., has_bn = False, train = True, update_ema = False, ema_decay = 0.995, use_base_params = False, centering = False, init_params = None, init_batch_params = None):
images = training_batch['images']
labels = training_batch['labels']
if has_bn:
batch_stats = train_state.batch_stats
else:
batch_stats = None
(loss, (new_batch_stats, acc, _)), grad = jax.value_and_grad(get_training_loss_l2, argnums = 0, has_aux = True)(train_state.params, images, labels, train_state, l2 = l2, train = train, has_bn = has_bn, batch_stats = batch_stats, use_base_params = use_base_params, centering = centering, init_params = init_params, init_batch_params = init_batch_params)
if has_bn:
new_state = train_state.apply_gradients(grads = grad, batch_stats = new_batch_stats, train_it = train_state.train_it + 1)
else:
new_state = train_state.apply_gradients(grads = grad, train_it = train_state.train_it + 1)
if update_ema:
new_ema_hidden, new_ema_average = get_updated_ema(new_state.params, new_state.ema_hidden, ema_decay, new_state.train_it, order = 1)
new_state = new_state.replace(ema_average = new_ema_average, ema_hidden = new_ema_hidden)
return new_state, loss
@functools.partial(jax.jit, static_argnames=('has_bn', 'train', 'update_ema', 'use_base_params', 'max_forward_batch_size', 'use_x64'))
def do_training_step_krr(train_state, training_batch1, l2 = 0., has_bn = False, train = True, update_ema = False, ema_decay = 0.995, use_base_params = False, grad_indices = None, max_forward_batch_size = None, use_x64 = False):
images1 = training_batch1['images']
labels1 = training_batch1['labels']
if has_bn:
batch_stats = train_state.batch_stats
else:
batch_stats = None
(loss, (new_batch_stats, acc, _)), grad = jax.value_and_grad(get_krr_loss_gd, argnums = 0, has_aux = True)(train_state.params, train_state, images1, labels1, None, None, l2 = l2, has_bn = has_bn, batch_stats = batch_stats, use_base_params = use_base_params, self_loss = True, grad_indices = grad_indices, max_forward_batch_size = max_forward_batch_size, use_x64 = use_x64)
if has_bn:
new_state = train_state.apply_gradients(grads = grad, batch_stats = new_batch_stats, train_it = train_state.train_it + 1)
else:
new_state = train_state.apply_gradients(grads = grad, train_it = train_state.train_it + 1)
if update_ema:
new_ema_hidden, new_ema_average = get_updated_ema(new_state.params, new_state.ema_hidden, ema_decay, new_state.train_it, order = 1)
new_state = new_state.replace(ema_average = new_ema_average, ema_hidden = new_ema_hidden)
return new_state, loss
def eval_on_test_set(train_state, test_loader, has_bn = False, use_ema = False, centering = False, init_params = None, init_batch_params = None):
n_total = 0
n_correct = 0
params_to_use = train_state.params
if use_ema:
params_to_use = train_state.ema_average
if has_bn:
batch_stats = train_state.batch_stats
else:
batch_stats = None
for images, labels in test_loader.as_numpy_iterator():
_, (_, _, n) = get_training_loss_l2(params_to_use, images, labels, train_state, l2 = 0, train = False, has_bn = has_bn, batch_stats = batch_stats, centering = centering, init_params = init_params, init_batch_params = init_batch_params)
n_correct += n
n_total += labels.shape[0]
return n_correct/n_total
class TrainStateWithBatchStats(train_state.TrainState):
batch_stats: flax.core.FrozenDict
train_it: int
ema_hidden: Any = None
ema_average: Any = None
base_params: Any = None
class CoresetTrainState(train_state.TrainState):
#A version of the train state that also returns the update when we apply gradients
train_it: int
ema_hidden: Any = None
ema_average: Any = None
def apply_gradients_get_updates(self, *, grads, **kwargs):
updates, new_opt_state = self.tx.update(
grads, self.opt_state, self.params)
new_params = optax.apply_updates(self.params, updates)
return self.replace(
step=self.step + 1,
params=new_params,
opt_state=new_opt_state,
**kwargs,
), updates
class ProtoHolder(nn.Module):
x_proto_init: Any
y_proto_init: Any
temp_init: Any
num_prototypes: int
learn_label: bool = True
use_flip: bool = False
@nn.compact
def __call__(self, ):
x_proto = self.param('x_proto', lambda *_: self.x_proto_init)
y_proto = self.param('y_proto', lambda *_: self.y_proto_init)
log_temp = self.param('log_temp', lambda *_: self.temp_init)
if not self.learn_label:
y_proto = jax.lax.stop_gradient(y_proto)
if self.use_flip:
return jnp.concatenate([x_proto, jnp.flip(x_proto, axis = -2)], axis = 0), jnp.concatenate([y_proto, y_proto], axis = 0), log_temp
return x_proto, y_proto, log_temp
def get_linear_forward(net_model_apply, has_bn = False, linearize = True):
if has_bn:
def inner_fn(inner_params, images, batch_stats, **kwargs):
return net_model_apply({'params': inner_params, 'batch_stats': batch_stats}, images, **kwargs)
def linear_forward(variables_dict, images, use_base_params = False, add_primals = False, return_all = False, **kwargs):
if use_base_params:
return net_model_apply({'params': variables_dict['params']['base_params'], 'batch_stats': variables_dict['batch_stats']}, images, **kwargs)
else:
base_variables_dict = jax.lax.stop_gradient(variables_dict['params']['base_params'])
if linearize:
primals, duals, aux = jax.jvp(utils.bind(inner_fn, ... , images, variables_dict['batch_stats'], **kwargs), (base_variables_dict,), (variables_dict['params']['tangent_params'],), has_aux = True)
else:
primals, aux = inner_fn(base_variables_dict, images, variables_dict['batch_stats'], **kwargs)
dual_variable_dict = utils._add(base_variables_dict, variables_dict['params']['tangent_params'])
duals, _ = inner_fn(dual_variable_dict, images, variables_dict['batch_stats'], **kwargs)
duals = utils._sub(duals, primals)
if return_all:
return primals, duals, aux
if add_primals:
return utils._add(primals, duals), aux
return duals, aux
else:
def inner_fn(inner_params, images, **kwargs):
return net_model_apply({'params': inner_params}, images, **kwargs)
def linear_forward(variables_dict, images, use_base_params = False, add_primals = False, return_all = False, **kwargs):
if use_base_params:
return net_model_apply({'params': variables_dict['params']['base_params']}, images, **kwargs)
else:
base_variables_dict = jax.lax.stop_gradient(variables_dict['params']['base_params'])
if linearize:
primals, duals, aux = jax.jvp(utils.bind(inner_fn, ... , images, **kwargs), (base_variables_dict,), (variables_dict['params']['tangent_params'],), has_aux=True)
else:
primals, aux = inner_fn(base_variables_dict, images, **kwargs)
dual_variable_dict = utils._add(base_variables_dict, variables_dict['params']['tangent_params'])
duals, _ = inner_fn(dual_variable_dict, images, **kwargs)
duals = utils._sub(duals, primals)
if return_all:
return primals, duals, aux
if add_primals:
return utils._add(primals, duals), aux
return duals, aux
return linear_forward
def get_training_loss_hvp(params, images, labels, net_train_state, v, l2 = 0, has_bn = False, batch_stats = None):
def hvp(primals, tangents):
return jax.jvp(jax.grad(utils.bind(get_training_loss_l2, ..., images, labels, net_train_state, l2 = l2, has_bn = has_bn, batch_stats = batch_stats, train = False), has_aux = True), [primals], [tangents], has_aux = True)[1]
return hvp(params, v)
def get_training_loss_hvp_krr(params, coreset_images, coreset_labels, net_train_state, v, l2 = 0, has_bn = False, batch_stats = None, grad_indices = None, pre_s = None, alg_config = None):
def hvp(primals, tangents):
return jax.jvp(jax.grad(utils.bind(get_krr_loss_gd, ..., net_train_state, coreset_images, coreset_labels, None, None, l2 = l2, has_bn = has_bn, batch_stats = batch_stats, self_loss = True, grad_indices = grad_indices, pre_s = pre_s, max_forward_batch_size = alg_config.max_forward_batch_size, use_x64 = alg_config.use_x64), has_aux = True), [primals], [tangents], has_aux = True)[1]
return hvp(params, v)
@jax.jit
def _bias_correction(moment, decay, count):
"""Perform bias correction. This becomes a no-op as count goes to infinity."""
bias_correction = 1 - decay ** count
return jax.tree_map(lambda t: t / bias_correction.astype(t.dtype), moment)
@jax.jit
def _update_moment(updates, moments, decay, order):
"""Compute the exponential moving average of the `order`-th moment."""
return jax.tree_map(
lambda g, t: (1 - decay) * (g ** order) + decay * t, updates, moments)
@jax.jit
def get_updated_ema(updates, moments, decay, count, order = 1):
hidden = _update_moment(updates, moments, decay, order)
average = _bias_correction(hidden, decay, count)
return hidden, average
def multiply_by_scalar(x, s):
return jax.tree_util.tree_map(lambda x: s * x, x)
def get_dot_product(a, b):
return jnp.sum(sum_tree(utils._multiply(a, b)))
def sum_reduce(a, b):
return jnp.sum(a) + jnp.sum(b)
def sum_tree(x):
return jax.tree_util.tree_reduce(sum_reduce , x)
def init_proto(ds, num_prototypes_per_class, num_classes, class_subset=None, seed=0, scale_y=False, random_noise = False):
window_size = num_prototypes_per_class
reduce_func = lambda key, dataset: dataset.batch(window_size)
ds = ds.shuffle(num_prototypes_per_class * num_classes * 10, seed=seed)
ds = ds.group_by_window(key_func=lambda x, y: y, reduce_func=reduce_func, window_size=window_size)
if class_subset is None:
is_init = [0] * num_classes
else:
is_init = [1] * num_classes
for cls in class_subset:
is_init[cls] = 0
x_proto = [None] * num_classes
y_proto = [None] * num_classes
for ele in ds.as_numpy_iterator():
cls = ele[1][0]
if is_init[cls] == 1:
pass
else:
x_proto[cls] = ele[0]
y_proto[cls] = ele[1]
is_init[cls] = 1
if sum(is_init) == num_classes:
break
x_proto = np.concatenate([x for x in x_proto if x is not None], axis=0)
y_proto = np.concatenate([y for y in y_proto if y is not None], axis=0)
y_proto = jax.nn.one_hot(y_proto, num_classes)
if random_noise:
np.random.seed(seed)
x_proto = 0.3 * np.random.standard_normal(x_proto.shape)
# center and scale y_proto
y_proto = y_proto - 1 / num_classes
if scale_y:
y_scale = np.sqrt(num_classes / 10)
y_proto = y_proto / y_scale
return x_proto, y_proto | 53,189 | 50.242775 | 477 | py |
RCIG | RCIG-master/distill_dataset.py | import sys
# sys.path.append("..")
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
import fire
import ml_collections
from functools import partial
# from jax.config import config
# config.update("jax_enable_x64", True)
import jax
from absl import logging
import absl
import tensorflow as tf
tf.config.set_visible_devices([], 'GPU')
from flax.training import train_state, checkpoints
from dataloader import get_dataset, configure_dataloader
# from lib.dataset.dataloader import get_dataset, configure_dataloader
# from lib.models.utils import create_model
# from lib.datadistillation.utils import save_dnfr_image, save_proto_np
# from lib.datadistillation.frepo import proto_train_and_evaluate, init_proto, ProtoHolder
# from lib.training.utils import create_train_state
# from lib.dataset.augmax import get_aug_by_name
from clu import metric_writers
from collections import namedtuple
from models import ResNet18, KIP_ConvNet, linear_net, Conv
from augmax import get_aug_by_name
import numpy as np
import jax.numpy as jnp
import algorithms
import optax
import time
import pickle
import contextlib
import warnings
import json
from jax.config import config as jax_config
def get_config():
# Note that max_lr_factor and l2_regularization is found through grid search.
config = ml_collections.ConfigDict()
config.random_seed = 0
config.train_log = 'train_log'
config.train_img = 'train_img'
config.mixed_precision = False
config.resume = True
config.img_size = None
config.img_channels = None
config.num_prototypes = None
config.train_size = None
config.dataset = ml_collections.ConfigDict()
config.kernel = ml_collections.ConfigDict()
config.online = ml_collections.ConfigDict()
# Dataset
config.dataset.name = 'cifar100' # ['cifar10', 'cifar100', 'mnist', 'fashion_mnist', 'tiny_imagenet']
config.dataset.data_path = 'data/tensorflow_datasets'
config.dataset.zca_path = 'data/zca'
config.dataset.zca_reg = 0.1
# online
config.online.img_size = None
config.online.img_channels = None
config.online.mixed_precision = config.mixed_precision
config.online.optimizer = 'adam'
config.online.learning_rate = 0.0003
config.online.arch = 'dnfrnet'
config.online.output = 'feat_fc'
config.online.width = 128
config.online.normalization = 'identity'
# Kernel
config.kernel.img_size = None
config.kernel.img_channels = None
config.kernel.num_prototypes = None
config.kernel.train_size = None
config.kernel.mixed_precision = config.mixed_precision
config.kernel.resume = config.resume
config.kernel.optimizer = 'lamb'
config.kernel.learning_rate = 0.0003
config.kernel.batch_size = 1024
config.kernel.eval_batch_size = 1000
return config
def main(dataset_name = 'cifar10', data_path=None, zca_path=None, train_log=None, train_img=None, width=128, random_seed=0, message = 'Put your message here!', output_dir = None, n_images = 10, config_path = None, log_dir = None, max_steps = 10000, use_x64 = False, skip_tune = False, naive_loss = False, init_random_noise = False):
# --------------------------------------
# Setup
# --------------------------------------
if use_x64:
jax_config.update("jax_enable_x64", True)
logging.use_absl_handler()
if log_dir is None and output_dir is not None:
log_dir = output_dir
elif log_dir is None:
log_dir = './logs/'
if not os.path.exists('./{}'.format(log_dir)):
os.makedirs('./{}'.format(log_dir))
logging.get_absl_handler().use_absl_log_file('{}, {}'.format(int(time.time()), message), './{}/'.format(log_dir))
absl.flags.FLAGS.mark_as_parsed()
logging.set_verbosity('info')
logging.info('\n\n\n{}\n\n\n'.format(message))
config = get_config()
config.random_seed = random_seed
config.train_log = train_log if train_log else 'train_log'
config.train_img = train_img if train_img else 'train_img'
# --------------------------------------
# Dataset
# --------------------------------------
config.dataset.data_path = data_path if data_path else 'data/tensorflow_datasets'
config.dataset.zca_path = zca_path if zca_path else 'data/zca'
config.dataset.name = dataset_name
(ds_train, ds_test), preprocess_op, rev_preprocess_op, proto_scale = get_dataset(config.dataset)
coreset_images, coreset_labels = algorithms.init_proto(ds_train, n_images, config.dataset.num_classes, seed = random_seed, random_noise = init_random_noise)
num_prototypes = n_images * config.dataset.num_classes
print()
print(num_prototypes)
print()
config.kernel.num_prototypes = num_prototypes
y_transform = lambda y: tf.one_hot(y, config.dataset.num_classes, on_value=1 - 1 / config.dataset.num_classes,
off_value=-1 / config.dataset.num_classes)
ds_train = configure_dataloader(ds_train, batch_size=config.kernel.batch_size, y_transform=y_transform,
train=True, shuffle=True)
ds_test = configure_dataloader(ds_test, batch_size=config.kernel.eval_batch_size, y_transform=y_transform,
train=False, shuffle=False)
num_classes = config.dataset.num_classes
if config.dataset.img_shape[0] in [28, 32]:
depth = 3
elif config.dataset.img_shape[0] == 64:
depth = 4
elif config.dataset.img_shape[0] == 128:
depth = 5
else:
raise Exception('Invalid resolution for the dataset')
key = jax.random.PRNGKey(random_seed)
alg_config = ml_collections.ConfigDict()
if config_path is not None:
print(f'loading config from {config_path}')
logging.info(f'loading config from {config_path}')
loaded_dict = json.loads(open('./{}'.format(config_path), 'rb').read())
loaded_dict['direct_batch_sizes'] = tuple(loaded_dict['direct_batch_sizes'])
alg_config = ml_collections.config_dict.ConfigDict(loaded_dict)
alg_config.l2 = alg_config.l2_rate * config.kernel.num_prototypes
alg_config.use_x64 = use_x64
alg_config.naive_loss = naive_loss
alg_config.output_dir = output_dir
alg_config.max_steps = max_steps
alg_config.model_depth = depth
print(alg_config)
logging.info('using config from ./{}'.format(config_path))
logging.info(alg_config)
if output_dir is not None:
if not os.path.exists('./{}'.format(output_dir)):
os.makedirs('./{}'.format(output_dir))
with open('./{}/config.txt'.format(output_dir), 'a') as config_file:
config_file.write(repr(alg_config))
model_for_train = Conv(use_softplus = (alg_config.softplus_temp != 0), beta = alg_config.softplus_temp, num_classes = num_classes, width = width, depth = depth, normalization = 'batch' if alg_config.has_bn else 'identity')
#Tuning inner and hessian inverse learning rate
print("Tuning learning rates -- this may take a few minutes")
logging.info("Tuning learning rates -- this may take a few minutes")
inner_learning_rate = 0.00001 #initialize them to be small, then gradually increase until unstable
hvp_learning_rate = 0.00005
start_time = time.time()
if not skip_tune:
with contextlib.redirect_stdout(None):
# if True:
inner_result = 1
while inner_result == 1:
inner_result, _ = algorithms.run_rcig(coreset_images, coreset_labels, model_for_train.init, model_for_train.apply, ds_train, alg_config, key, inner_learning_rate, hvp_learning_rate, lr_tune = True)
inner_learning_rate *= 1.2
inner_learning_rate *= 0.7
hvp_result = 1
while hvp_result == 1:
_, hvp_result = algorithms.run_rcig(coreset_images, coreset_labels, model_for_train.init, model_for_train.apply, ds_train, alg_config, key, inner_learning_rate, hvp_learning_rate, lr_tune = True)
hvp_learning_rate *= 1.2
hvp_learning_rate *= 0.7
print("Done tuning learning rates")
print(f'inner_learning_rate: {inner_learning_rate} hvp learning_rate: {hvp_learning_rate}')
logging.info("Done tuning learning rates")
logging.info(f'inner_learning_rate: {inner_learning_rate} hvp learning_rate: {hvp_learning_rate}')
logging.info(f'Completed LR tune in {time.time() - start_time}s')
#Training
logging.info('Begin training')
start_time = time.time()
coreset_train_state, key, pool, inner_learning_rate, hvp_learning_rate = algorithms.run_rcig(coreset_images, coreset_labels, model_for_train.init, model_for_train.apply, ds_train, alg_config, key, inner_learning_rate, hvp_learning_rate, start_iter = 0)
logging.info(f'Completed in {time.time() - start_time}s')
logging.info(f'Saving final checkpoint')
checkpoints.save_checkpoint(ckpt_dir = './{}/'.format(alg_config.output_dir), target = coreset_train_state, step = 'final', keep = 1e10)
#Save version for visualizing (without ZCA transform)
visualize_output_dict = {
'coreset_images': np.array(rev_preprocess_op(coreset_train_state.ema_average['x_proto'])),
'coreset_labels': np.array(coreset_train_state.ema_average['y_proto']),
'dataset': config.dataset
}
if output_dir is not None:
pickle.dump(visualize_output_dict, open('./{}/{}.pkl'.format(output_dir, 'distilled_dataset_vis'), 'wb'))
print(f'new learning rates: {inner_learning_rate}, {hvp_learning_rate}')
logging.info(f'new learning rates: {inner_learning_rate}, {hvp_learning_rate}')
if __name__ == '__main__':
tf.config.experimental.set_visible_devices([], 'GPU')
fire.Fire(main)
| 9,838 | 33.766784 | 332 | py |
RCIG | RCIG-master/augmax/base.py | # Copyright 2021 Konrad Heidler
#
# 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.
import jax
import jax.numpy as jnp
from abc import ABC, abstractmethod
from typing import Union, List, Tuple, Sequence
from enum import Enum
from .utils import unpack_list_if_singleton
class InputType(Enum):
IMAGE = 'image'
MASK = 'mask'
DENSE = 'dense'
CONTOUR = 'contour'
KEYPOINTS = 'keypoints'
def same_type(left_type, right_type):
if isinstance(left_type, InputType):
left_type = left_type.value
if isinstance(right_type, InputType):
right_type = right_type.value
return left_type.lower() == right_type.lower()
class Transformation(ABC):
def __init__(self, input_types=None):
if input_types is None:
self.input_types = [InputType.IMAGE]
else:
self.input_types = input_types
def __call__(self, rng: jnp.ndarray, *inputs: jnp.ndarray) -> Union[jnp.ndarray, Sequence[jnp.ndarray]]:
if len(self.input_types) != len(inputs):
raise ValueError(f"List of input types (length {len(self.input_types)}) must match inputs to Augmentation (length {len(inputs)})")
augmented = self.apply(rng, inputs, self.input_types)
return unpack_list_if_singleton(augmented)
def invert(self, rng: jnp.ndarray, *inputs: jnp.ndarray) -> Union[jnp.ndarray, Sequence[jnp.ndarray]]:
if len(self.input_types) != len(inputs):
raise ValueError(f"List of input types (length {len(self.input_types)}) must match inputs to Augmentation (length {len(inputs)})")
augmented = self.apply(rng, inputs, self.input_types, invert=True)
return unpack_list_if_singleton(augmented)
@abstractmethod
def apply(self, rng: jnp.ndarray, inputs: Sequence[jnp.ndarray], input_types: Sequence[InputType]=None, invert=False) -> List[jnp.ndarray]:
if input_types is None:
input_types = self.input_types
val = []
for input, type in zip(inputs, input_types):
val.append(input)
return val
class BaseChain(Transformation):
def __init__(self, *transforms: Transformation, input_types=[InputType.IMAGE]):
super().__init__(input_types)
self.transforms = transforms
def apply(self, rng: jnp.ndarray, inputs: jnp.ndarray, input_types: Sequence[InputType]=None, invert=False) -> List[jnp.ndarray]:
if input_types is None:
input_types = self.input_types
N = len(self.transforms)
subkeys = [None]*N if rng is None else jax.random.split(rng, N)
transforms = self.transforms
if invert:
transforms = reversed(transforms)
subkeys = reversed(subkeys)
images = list(inputs)
for transform, subkey in zip(transforms, subkeys):
images = transform.apply(subkey, images, input_types, invert=invert)
return images
def __repr__(self):
members_repr = ",\n".join(str(t) for t in self.transforms)
members_repr = '\n'.join(['\t'+line for line in members_repr.split('\n')])
return f'{self.__class__.__name__}(\n{members_repr}\n)'
| 3,662 | 37.968085 | 143 | py |
RCIG | RCIG-master/augmax/export.py | import jax
from .geometric import RandomSizedCrop, Rotate, HorizontalFlip, RandomTranslate
from .imagelevel import NormalizedColorJitter, Cutout
def get_vmap_transform(transform, use_siamese=False):
if use_siamese:
vmap_transform = jax.vmap(transform, in_axes=[None, 0])
else:
transform = jax.vmap(transform, in_axes=[0, 0])
def vmap_transform(rng, img):
bs = img.shape[0]
rngs = jax.random.split(rng, bs)
return transform(rngs, img)
return vmap_transform
def get_aug_by_name(strategy, res=32):
transform = dict(color=jax.jit(get_vmap_transform(NormalizedColorJitter(
brightness=0.25, contrast=0.25, saturation=0.25, p=1.0), use_siamese=False)),
crop=jax.jit(
get_vmap_transform(RandomSizedCrop(width=res, height=res, zoom_range=(0.8, 1.25)), use_siamese=False)),
translate=jax.jit(get_vmap_transform(RandomTranslate(ratio=0.125), use_siamese=False)),
cutout=jax.jit(
get_vmap_transform(Cutout(num_holes=1, max_h_size=res // 4, max_w_size=res // 4, fill_value=0.0, p=1.0),
use_siamese=False)),
flip=jax.jit(get_vmap_transform(HorizontalFlip(p=0.5), use_siamese=False)),
rotate=jax.jit(get_vmap_transform(Rotate(angle_range=(-15, 15), p=1.0), use_siamese=False)))
strategy = strategy.split('_')
transforms = []
for s in strategy:
transforms.append(transform[s])
def trans(rng, x):
i = jax.random.randint(key=rng, shape=(1,), minval=0, maxval=len(transforms))[0]
return jax.lax.switch(i, transforms, rng, x)
def vmap_transform(rng, img):
bs = img.shape[0]
rngs = jax.random.split(rng, bs)
return (jax.vmap(trans, )(rngs, img[:, None])).squeeze(1)
return vmap_transform
# return trans
| 1,858 | 35.45098 | 116 | py |
RCIG | RCIG-master/augmax/geometric.py | # Copyright 2021 Konrad Heidler
#
# 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.
from typing import Union, List, Tuple
from abc import abstractmethod
import math
import warnings
import jax
import jax.numpy as jnp
from einops import rearrange
from .base import Transformation, BaseChain, InputType, same_type
from . import utils
class LazyCoordinates:
_current_transform: jnp.ndarray = jnp.eye(3)
_offsets: Union[jnp.ndarray, None] = None
input_shape: Tuple[int, int]
current_shape: Tuple[int, int]
final_shape: Tuple[int, int]
def __init__(self, shape: Tuple[int, int]):
self.input_shape = shape
self.current_shape = shape
self.final_shape = shape
def get_coordinate_grid(self) -> jnp.ndarray:
H, W = self.final_shape
coordinates = jnp.mgrid[0:H, 0:W] - jnp.array([H / 2 - 0.5, W / 2 - 0.5]).reshape(2, 1, 1)
coordinates = utils.apply_perspective(coordinates, self._current_transform)
if self._offsets is not None:
coordinates = coordinates + self._offsets
H, W = self.input_shape
return coordinates + jnp.array([H / 2 - 0.5, W / 2 - 0.5]).reshape(2, 1, 1)
def apply_to_points(self, points) -> jnp.ndarray:
M_inv = jnp.linalg.inv(self._current_transform)
H_in, W_in = self.input_shape
H_out, W_out = self.final_shape
c_x = jnp.array([H_in / 2 - 0.5, W_in / 2 - 0.5]).reshape(2, 1)
c_y = jnp.array([H_out / 2 - 0.5, W_out / 2 - 0.5]).reshape(2, 1)
points = points.T
transformed_points = utils.apply_perspective(points - c_x, M_inv) + c_y
if self._offsets is not None:
# Need to do fix-point iteration
points_iter = transformed_points
offset_grid = rearrange(self._offsets, 'c h w -> h w c')
for _ in range(2):
# fix-point iteration
offsets = utils.resample_image(offset_grid, points_iter, order=1).T
points_iter = utils.apply_perspective(points - offsets - c_x, M_inv) + c_y
transformed_points = points_iter
return transformed_points.T
def push_transform(self, M: jnp.ndarray):
assert M.shape == (3, 3)
self._current_transform = M @ self._current_transform
self._dirty = True
def apply_pixelwise_offsets(self, offsets):
assert offsets.shape[1:] == self.final_shape
if self._offsets == None:
self._offsets = offsets
else:
self._offsets = self._offsets + offsets
class GeometricTransformation(Transformation):
@abstractmethod
def transform_coordinates(self, rng: jnp.ndarray, coordinates: LazyCoordinates, invert=False) -> LazyCoordinates:
return coordinates
def apply(self, rng: jnp.ndarray, inputs: jnp.ndarray, input_types: List[InputType] = None, invert=False) -> List[
jnp.ndarray]:
if input_types is None:
input_types = self.input_types
input_shape = inputs[0].shape[:2]
output_shape = self.output_shape(input_shape)
if invert:
if not self.size_changing():
output_shape = input_shape
elif hasattr(self, 'shape_full'):
output_shape = self.shape_full
else:
raise ValueError("Can't invert a size-changing transformation without running it forward once.")
else:
self.shape_full = input_shape
coordinates = LazyCoordinates(input_shape)
coordinates.final_shape = output_shape
if invert:
coordinates.current_shape = output_shape
self.transform_coordinates(rng, coordinates, invert)
sampling_coords = coordinates.get_coordinate_grid()
val = []
for input, type in zip(inputs, input_types):
current = None
if same_type(type, InputType.IMAGE) or same_type(type, InputType.DENSE):
# Linear Interpolation for Images
current = utils.resample_image(input, sampling_coords, order=1, mode='nearest')
# current = utils.resample_image(input, sampling_coords, order=1, mode='constant')
elif same_type(type, InputType.MASK):
# Nearest Interpolation for Masks
current = utils.resample_image(input, sampling_coords, order=0, mode='nearest')
elif same_type(type, InputType.KEYPOINTS):
current = coordinates.apply_to_points(input)
elif same_type(type, InputType.CONTOUR):
current = coordinates.apply_to_points(input)
current = jnp.where(jnp.linalg.det(coordinates._current_transform) < 0,
current[::-1],
current
)
if current is None:
raise NotImplementedError(f"Cannot transform input of type {type} with {self.__class__.__name__}")
val.append(current)
return val
def output_shape(self, input_shape: Tuple[int, int]) -> Tuple[int, int]:
return input_shape
def size_changing(self):
return False
# if invert:
# if hasattr(self, 'shape_full'):
# output_shape = self.shape_full
# elif self.size_changing():
# raise ValueError("Can't invert a size-changing transformation without running it forward once.")
class SizeChangingGeometricTransformation(GeometricTransformation):
def size_changing(self):
return True
class GeometricChain(GeometricTransformation, BaseChain):
def __init__(self, *transforms: GeometricTransformation):
super().__init__()
for transform in transforms:
assert isinstance(transform, GeometricTransformation), f"{transform} is not a GeometricTransformation!"
self.transforms = transforms
def transform_coordinates(self, rng: jnp.ndarray, coordinates: LazyCoordinates, invert=False):
shape_chain = [coordinates.input_shape]
for transform in self.transforms:
shape_chain.append(transform.output_shape(shape_chain[-1]))
N = len(self.transforms)
subkeys = [None] * N if rng is None else jax.random.split(rng, N)
transforms = self.transforms
if not invert:
# Reverse the transformations iff not inverting!
transforms = reversed(transforms)
subkeys = reversed(subkeys)
shape_chain = reversed(shape_chain[:-1])
for transform, current_shape, subkey in zip(transforms, shape_chain, subkeys):
coordinates.current_shape = current_shape
transform.transform_coordinates(subkey, coordinates, invert=invert)
return coordinates
def output_shape(self, input_shape: Tuple[int, int]) -> Tuple[int, int]:
shape = input_shape
for transform in self.transforms:
shape = transform.output_shape(shape)
return shape
def size_changing(self):
return any(t.size_changing() for t in self.transforms)
class HorizontalFlip(GeometricTransformation):
"""Randomly flips an image horizontally.
Args:
p (float): Probability of applying the transformation
"""
def __init__(self, p: float = 0.5):
super().__init__()
self.probability = p
def transform_coordinates(self, rng: jnp.ndarray, coordinates: LazyCoordinates, invert=False):
f = 1. - 2. * jax.random.bernoulli(rng, self.probability)
transform = jnp.array([
[1, 0, 0],
[0, f, 0],
[0, 0, 1]
])
coordinates.push_transform(transform)
class VerticalFlip(GeometricTransformation):
"""Randomly flips an image vertically.
Args:
p (float): Probability of applying the transformation
"""
def __init__(self, p: float = 0.5):
super().__init__()
self.probability = p
def transform_coordinates(self, rng: jnp.ndarray, coordinates: LazyCoordinates, invert=False):
f = 1. - 2. * jax.random.bernoulli(rng, self.probability)
transform = jnp.array([
[f, 0, 0],
[0, 1, 0],
[0, 0, 1]
])
coordinates.push_transform(transform)
class RandomFlip(GeometricTransformation):
"""Randomly flips an image vertically.
Args:
p (float): Probability of applying the transformation
"""
def __init__(self, p: float = 0.5):
super().__init__()
self.probability = p
def transform_coordinates(self, rng: jnp.ndarray, coordinates: LazyCoordinates, invert=False):
key1, key2 = jax.random.split(rng)
f1 = 1. - 2. * jax.random.bernoulli(key1, self.probability)
f2 = 1. - 2. * jax.random.bernoulli(key2, self.probability)
transform = jnp.array([
[f1, 0, 0],
[0, f2, 0],
[0, 0, 1]
])
coordinates.push_transform(transform)
class Rotate90(GeometricTransformation):
"""Randomly rotates the image by a multiple of 90 degrees.
"""
def __init__(self):
super().__init__()
def transform_coordinates(self, rng: jnp.ndarray, coordinates: LazyCoordinates, invert=False):
params = jax.random.bernoulli(rng, 0.5, [2])
flip = 1. - 2. * params[0]
rot = params[1]
if invert:
flip = (2. * rot - 1.) * flip
transform = jnp.array([
[flip * rot, flip * (1. - rot), 0],
[flip * (-1. + rot), flip * rot, 0],
[0, 0, 1]
])
coordinates.push_transform(transform)
class Rotate(GeometricTransformation):
"""Rotates the image by a random arbitrary angle.
Args:
angle_range (float, float): Tuple of `(min_angle, max_angle)` to sample from.
If only a single number is given, angles will be sampled from `(-angle_range, angle_range)`.
p (float): Probability of applying the transformation
"""
def __init__(self,
angle_range: Union[Tuple[float, float], float] = (-30, 30),
p: float = 1.0):
super().__init__()
if not hasattr(angle_range, '__iter__'):
angle_range = (-angle_range, angle_range)
self.theta_min, self.theta_max = map(math.radians, angle_range)
self.probability = p
def transform_coordinates(self, rng: jnp.ndarray, coordinates: LazyCoordinates, invert=False):
do_apply = jax.random.bernoulli(rng, self.probability)
theta = do_apply * jax.random.uniform(rng, minval=self.theta_min, maxval=self.theta_max)
if invert:
theta = -theta
transform = jnp.array([
[jnp.cos(theta), jnp.sin(theta), 0],
[-jnp.sin(theta), jnp.cos(theta), 0],
[0, 0, 1]
])
coordinates.push_transform(transform)
class Translate(GeometricTransformation):
def __init__(self, dx, dy):
super().__init__()
self.dx = dx
self.dy = dy
def transform_coordinates(self, rng: jnp.ndarray, coordinates: LazyCoordinates, invert=False):
dy = self.dy
dx = self.dx
if invert:
dy = -dy
dx = -dx
transform = jnp.array([
[1, 0, -dy],
[0, 1, -dx],
[0, 0, 1]
])
coordinates.push_transform(transform)
class RandomTranslate(GeometricTransformation):
"""Random Translation with given ratio.
Args:
ratio (float): translation ratio
"""
def __init__(self, ratio: float = 0.25):
super().__init__()
self.ratio = ratio
def transform_coordinates(self, rng: jnp.ndarray, coordinates: LazyCoordinates, invert=False):
H, W = coordinates.current_shape
limit_y = H * self.ratio
limit_x = W * self.ratio
dy, dx = jax.random.uniform(rng, [2],
minval=jnp.array([-limit_y, -limit_x]),
maxval=jnp.array([limit_y, limit_x]))
if invert:
dy = -dy
dx = -dx
transform = jnp.array([
[1, 0, -dy],
[0, 1, -dx],
[0, 0, 1]
])
coordinates.push_transform(transform)
class Crop(SizeChangingGeometricTransformation):
"""Crop the image at the specified x0 and y0 with given width and height
Args:
x0 (float): x-coordinate of the crop's top-left corner
y0 (float): y-coordinate of the crop's top-left corner
w (float): width of the crop
h (float): height of the crop
"""
def __init__(self, x0, y0, w, h):
super().__init__()
self.x0 = x0
self.y0 = y0
self.width = w
self.height = h
def transform_coordinates(self, rng: jnp.ndarray, coordinates: LazyCoordinates, invert=False):
H, W = coordinates.current_shape
center_x = self.x0 + self.width / 2 - W / 2
center_y = self.y0 + self.height / 2 - H / 2
# self.dx/dy is in (0,0) -- (H,W) reference frame
# => push it to (-H/2, -W/2) -- (H/2, W/2) reference frame
# Forward transform: Translate by (dx, dy)
if invert:
center_y = -center_y
center_x = -center_x
transform = jnp.array([
[1, 0, center_y],
[0, 1, center_x],
[0, 0, 1]
])
coordinates.push_transform(transform)
def output_shape(self, input_shape: Tuple[int, int]) -> Tuple[int, int]:
return (self.height, self.width)
class Resize(SizeChangingGeometricTransformation):
def __init__(self, width: int, height: int = None):
super().__init__()
self.width = width
self.height = width if height is None else height
def output_shape(self, input_shape: Tuple[int, int]) -> Tuple[int, int]:
return (self.height, self.width)
def __repr__(self):
return f'Resize({self.width}, {self.height})'
def transform_coordinates(self, rng: jnp.ndarray, coordinates: LazyCoordinates, invert=False):
H, W = coordinates.current_shape
H_, W_ = self.height, self.width
sy = H / H_
sx = W / W_
if invert:
sy = 1 / sy
sx = 1 / sx
transform = jnp.array([
[sy, 0, 0],
[0, sx, 0],
[0, 0, 1],
])
coordinates.push_transform(transform)
class CenterCrop(SizeChangingGeometricTransformation):
"""Extracts a central crop from the image with given width and height.
Args:
w (float): width of the crop
h (float): height of the crop
"""
width: int
height: int
def __init__(self, width: int, height: int = None):
super().__init__()
self.width = width
self.height = width if height is None else height
def transform_coordinates(self, rng: jnp.ndarray, coordinates: LazyCoordinates, invert=False):
# Cropping is done implicitly via output_shape
pass
def output_shape(self, input_shape: Tuple[int, int]) -> Tuple[int, int]:
return (self.height, self.width)
def __repr__(self):
return f'CenterCrop({self.width}, {self.height})'
class RandomCrop(SizeChangingGeometricTransformation):
"""Extracts a random crop from the image with given width and height.
Args:
w (float): width of the crop
h (float): height of the crop
"""
width: int
height: int
def __init__(self, width: int, height: int = None):
super().__init__()
self.width = width
self.height = width if height is None else height
def transform_coordinates(self, rng: jnp.ndarray, coordinates: LazyCoordinates, invert=False):
H, W = coordinates.current_shape
limit_y = (H - self.height) / 2
limit_x = (W - self.width) / 2
center_y, center_x = jax.random.uniform(rng, [2],
minval=jnp.array([-limit_y, -limit_x]),
maxval=jnp.array([limit_y, limit_x]))
if invert:
center_y = -center_y
center_x = -center_x
transform = jnp.array([
[1, 0, center_y],
[0, 1, center_x],
[0, 0, 1]
])
coordinates.push_transform(transform)
def output_shape(self, input_shape: Tuple[int, int]) -> Tuple[int, int]:
return (self.height, self.width)
class RandomSizedCrop(SizeChangingGeometricTransformation):
"""Extracts a randomly sized crop from the image and rescales it to the given width and height.
Args:
w (float): width of the crop
h (float): height of the crop
zoom_range (float, float): minimum and maximum zoom level for the transformation
prevent_underzoom (bool): whether to prevent zooming beyond the image size
"""
width: int
height: int
min_zoom: float
max_zoom: float
def __init__(self,
width: int, height: int = None, zoom_range: Tuple[float, float] = (0.5, 2.0),
prevent_underzoom: bool = True):
super().__init__()
self.width = width
self.height = width if height is None else height
self.min_zoom = zoom_range[0]
self.max_zoom = zoom_range[1]
self.prevent_underzoom = prevent_underzoom
def transform_coordinates(self, rng: jnp.ndarray, coordinates: LazyCoordinates, invert=False):
H, W = coordinates.current_shape
key1, key2 = jax.random.split(rng)
if self.prevent_underzoom:
min_zoom = max(self.min_zoom, math.log(self.height / H), math.log(self.width / W))
max_zoom = max(self.max_zoom, min_zoom)
else:
min_zoom = self.min_zoom
max_zoom = self.max_zoom
zoom = utils.log_uniform(key1, minval=min_zoom, maxval=max_zoom)
limit_y = jnp.absolute(((H * zoom) - self.height) / 2)
limit_x = jnp.absolute(((W * zoom) - self.width) / 2)
center = jax.random.uniform(key2, [2],
minval=jnp.array([-limit_y, -limit_x]),
maxval=jnp.array([limit_y, limit_x]))
# Out matrix:
# [ 1/zoom 0 1/c_y ]
# [ 0 1/zoom 1/c_x ]
# [ 0 0 1 ]
if not invert:
transform = jnp.concatenate([
jnp.concatenate([jnp.eye(2), center.reshape(2, 1)], axis=1) / zoom,
jnp.array([[0, 0, 1]])
], axis=0)
else:
transform = jnp.concatenate([
jnp.concatenate([jnp.eye(2) * zoom, -center.reshape(2, 1)], axis=1),
jnp.array([[0, 0, 1]])
], axis=0)
coordinates.push_transform(transform)
def output_shape(self, input_shape: Tuple[int, int]) -> Tuple[int, int]:
return (self.height, self.width)
class Warp(GeometricTransformation):
"""
Warp an image (similar to ElasticTransform).
Args:
strength (float): How strong the transformation is, corresponds to the standard deviation of
deformation values.
coarseness (float): Size of the initial deformation grid cells. Lower values lead to a more noisy deformation.
"""
def __init__(self, strength: int = 5, coarseness: int = 32):
super().__init__()
self.strength = strength
self.coarseness = coarseness
def transform_coordinates(self, rng: jnp.ndarray, coordinates: LazyCoordinates, invert=False):
if invert:
warnings.warn("Inverting a Warp transform not yet implemented. Returning warped image as is.")
return
H, W = coordinates.final_shape
H_, W_ = H // self.coarseness, W // self.coarseness
coordshift_coarse = self.strength * jax.random.normal(rng, [2, H_, W_])
# Note: This is not 100% correct as it ignores possible perspective conmponents of
# the current transform. Also, interchanging resize and transform application
# is a speed hack, but this shouldn't diminish the quality.
coordshift = jnp.tensordot(coordinates._current_transform[:2, :2], coordshift_coarse, axes=1)
coordshift = jax.image.resize(coordshift, (2, H, W), method='bicubic')
coordinates.apply_pixelwise_offsets(coordshift)
| 20,941 | 33.729685 | 118 | py |
RCIG | RCIG-master/augmax/utils.py | # Copyright 2021 Konrad Heidler
#
# 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.
from typing import Union, Any, Sequence, Tuple, TypeVar, Iterable
import jax
import jax.numpy as jnp
import jax.scipy.ndimage as jnd
def apply_perspective(xy: jnp.ndarray, M: jnp.ndarray) -> jnp.ndarray:
xyz = jnp.concatenate([xy, jnp.ones([1, *xy.shape[1:]])])
xyz = jnp.tensordot(M, xyz, axes=1)
yx, z = jnp.split(xyz, [2])
return yx / z
def resample_image(image: jnp.ndarray, coordinates: jnp.ndarray, order: int = 1, mode: str = 'nearest', cval: Any = 0):
H, W, *C = image.shape
D, *S_out = coordinates.shape
assert D == 2, f'Expected first dimension of coordinates array to have size 2, got {coordinates.shape}'
coordinates = coordinates.reshape(2, -1)
def resample_channel(channel: jnp.ndarray):
return jnd.map_coordinates(channel, coordinates, order=order, mode=mode, cval=cval)
if image.ndim == 2:
resampled = resample_channel(image)
elif image.ndim == 3:
resampled = jax.vmap(resample_channel, in_axes=-1, out_axes=-1)(image)
else:
raise ValueError(f"Cannot resample image with {image.ndim} dimensions")
resampled = resampled.reshape(*S_out, *C)
return resampled
def log_uniform(key, shape=(), dtype=jnp.float32, minval=0.5, maxval=2.0):
logmin = jnp.log(minval)
logmax = jnp.log(maxval)
sample = jax.random.uniform(key, minval=logmin, maxval=logmax)
return jnp.exp(sample)
def cutout(img: jnp.ndarray, holes: Iterable[Tuple[int, int, int, int]],
fill_value: Union[int, float] = 0) -> jnp.ndarray:
# Make a copy of the input image since we don't want to modify it directly
img = img.copy()
for x1, y1, x2, y2 in holes:
img[y1:y2, x1:x2] = fill_value
return img
def rgb_to_hsv(pixel: jnp.ndarray) -> Tuple[jnp.ndarray, jnp.ndarray, jnp.ndarray]:
"""
cf. https://en.wikipedia.org/wiki/HSL_and_HSV#Color_conversion_formulae
Note: This operation is applied pixelwise. To applied imagewise, apply vmap first.
full_op = jax.jit(jax.vmap(jax.vmap(op, [None, 0], 0), [None, 1], 1))
Other possible implementation: https://kornia.readthedocs.io/en/latest/_modules/kornia/color/hsv.html
"""
value = jnp.max(pixel)
range = value - jnp.min(pixel)
argmax = jnp.argmax(pixel)
second = jnp.mod(argmax + 1, 3)
third = jnp.mod(argmax + 2, 3)
hue = jnp.where(range == 0.0, 0.0, (2 * argmax + (pixel[second] - pixel[third]) / range) / 6)
saturation = jnp.where(value == 0, 0.0, range / value)
return hue, saturation, value
def hsv_to_rgb(hue: jnp.ndarray, saturation: jnp.ndarray, value: jnp.ndarray) -> jnp.ndarray:
"""
cf. https://en.wikipedia.org/wiki/HSL_and_HSV#Color_conversion_formulae
Note: This operation is applied pixelwise. To applied imagewise, apply vmap first.
full_op = jax.jit(jax.vmap(jax.vmap(op, [None, 0], 0), [None, 1], 1))
Other possible implementation: https://kornia.readthedocs.io/en/latest/_modules/kornia/color/hsv.html
"""
n = jnp.array([5, 3, 1])
k = jnp.mod(n + hue * 6, 6)
f = value - value * saturation * jnp.maximum(0, jnp.minimum(jnp.minimum(k, 4 - k), 1))
return f
T = TypeVar('T')
def unpack_list_if_singleton(arbitrary_list: Sequence[T]) -> Union[T, Sequence[T]]:
if len(arbitrary_list) == 1:
return arbitrary_list[0]
else:
return tuple(arbitrary_list)
| 3,946 | 35.546296 | 119 | py |
RCIG | RCIG-master/augmax/colorspace.py | # Copyright 2021 Konrad Heidler
#
# 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.
from abc import abstractmethod
from typing import List, Tuple
from functools import partial
import numpy as np
import jax
import jax.numpy as jnp
import warnings
from .base import Transformation, BaseChain, InputType, same_type
from .utils import log_uniform, rgb_to_hsv, hsv_to_rgb
from .functional import colorspace as F
class ColorspaceTransformation(Transformation):
@abstractmethod
def pixelwise(self, rng: jnp.ndarray, pixel: jnp.ndarray, invert=False) -> jnp.ndarray:
return pixel
def apply(self, rng: jnp.ndarray, inputs: jnp.ndarray, input_types: List[InputType] = None, invert=False) -> List[
jnp.ndarray]:
if input_types is None:
input_types = self.input_types
op = partial(self.pixelwise, invert=invert)
full_op = jax.jit(jax.vmap(jax.vmap(op, [None, 0], 0), [None, 1], 1))
val = []
for input, type in zip(inputs, input_types):
current = None
if same_type(type, InputType.IMAGE):
# Linear Interpolation for Images
current = full_op(rng, input)
else:
current = input
val.append(current)
return val
class ColorspaceChain(ColorspaceTransformation, BaseChain):
def __init__(self, *transforms: ColorspaceTransformation, input_types=None):
super().__init__(input_types)
self.transforms = transforms
def pixelwise(self, rng: jnp.ndarray, pixel: jnp.ndarray, invert=False) -> jnp.ndarray:
N = len(self.transforms)
subkeys = [None] * N if rng is None else jax.random.split(rng, N)
transforms = self.transforms
if invert:
transforms = reversed(transforms)
subkeys = reversed(subkeys)
for transform, subkey in zip(transforms, subkeys):
pixel = transform.pixelwise(subkey, pixel, invert=invert)
return pixel
class ByteToFloat(ColorspaceTransformation):
"""Transforms images from uint8 representation (values 0-255)
to normalized float representation (values 0.0-1.0)
"""
def pixelwise(self, rng: jnp.ndarray, pixel: jnp.ndarray, invert=False) -> jnp.ndarray:
if invert:
return jnp.clip(255.0 * pixel, 0, 255).astype(jnp.uint8)
else:
return pixel.astype(jnp.float32) / 255.0
class Normalize(ColorspaceTransformation):
"""Normalizes images using given coefficients using the mapping
.. math::
p_k \\longmapsto \\frac{p_k - \\mathtt{mean}_k}{\\mathtt{std}_k}
Args:
mean (jnp.ndarray): Mean values for each channel
std (jnp.ndarray): Standard deviation for each channel
"""
def __init__(self,
mean: jnp.ndarray = jnp.array([0.485, 0.456, 0.406]),
std: jnp.ndarray = jnp.array([0.229, 0.224, 0.225]),
input_types=None
):
super().__init__(input_types)
self.mean = jnp.asarray(mean)
self.std = jnp.asarray(std)
def pixelwise(self, rng: jnp.ndarray, pixel: jnp.ndarray, invert=False) -> jnp.ndarray:
if not invert:
return (pixel - self.mean) / self.std
else:
return (pixel * self.std) + self.mean
class ChannelShuffle(ColorspaceTransformation):
"""Randomly shuffles an images channels.
Args:
p (float): Probability of applying the transformation
"""
def __init__(self,
p: float = 0.5,
input_types=None
):
super().__init__(input_types)
self.probability = p
def pixelwise(self, rng: jnp.ndarray, pixel: jnp.ndarray, invert=False) -> jnp.ndarray:
k1, k2 = jax.random.split(rng)
do_apply = jax.random.bernoulli(k2, self.probability)
if not invert:
return jnp.where(do_apply,
jax.random.permutation(k1, pixel),
pixel
)
else:
inv_permutation = jnp.argsort(jax.random.permutation(k1, pixel.shape[0]))
return jnp.where(do_apply,
pixel[inv_permutation],
pixel
)
class RandomGamma(ColorspaceTransformation):
"""Randomly adjusts the image gamma.
Args:
range (float, float):
p (float): Probability of applying the transformation
"""
def __init__(self,
range: Tuple[float, float] = (0.75, 1.33),
p: float = 0.5,
input_types=None
):
super().__init__(input_types)
self.range = range
self.probability = p
def pixelwise(self, rng: jnp.ndarray, pixel: jnp.ndarray, invert=False) -> jnp.ndarray:
if pixel.dtype != jnp.float32:
raise ValueError(f"RandomGamma can only be applied to float images, but the input is {pixel.dtype}. "
"Please call ByteToFloat first.")
k1, k2 = jax.random.split(rng)
random_gamma = log_uniform(k1, minval=self.range[0], maxval=self.range[1])
gamma = jnp.where(jax.random.bernoulli(k2, self.probability), random_gamma, 1.0)
if not invert:
return jnp.power(pixel, gamma)
else:
return jnp.power(pixel, 1 / gamma)
class RandomBrightness(ColorspaceTransformation):
"""Randomly adjusts the image brightness.
Args:
range (float, float):
p (float): Probability of applying the transformation
"""
def __init__(self,
range: Tuple[float, float] = (-0.5, 0.5),
p: float = 0.5,
input_types=None
):
super().__init__(input_types)
self.minval = range[0]
self.maxval = range[1]
self.probability = p
assert self.minval >= -1.0, "Brightness should be in the range [-1.0, 1.0], current minval = {}".format(
self.minval)
assert self.maxval <= 1.0, "Brightness should be in the range [-1.0, 1.0], current maxval = {}".format(
self.maxval)
def pixelwise(self, rng: jnp.ndarray, pixel: jnp.ndarray, invert=False) -> jnp.ndarray:
if pixel.dtype != jnp.float32:
raise ValueError(f"RandomContrast can only be applied to float images, but the input is {pixel.dtype}. "
"Please call ByteToFloat first.")
k1, k2 = jax.random.split(rng)
random_brightness = jax.random.uniform(k1, minval=self.minval, maxval=self.maxval)
brightness = jnp.where(jax.random.bernoulli(k2, self.probability), random_brightness, 0.0)
# cf. https://gitlab.gnome.org/GNOME/gimp/-/blob/master/app/operations/gimpoperationbrightnesscontrast.c
return F.adjust_brightness(pixel, brightness, invert=invert)
class RandomContrast(ColorspaceTransformation):
"""Randomly adjusts the image contrast.
Args:
range (float, float):
p (float): Probability of applying the transformation
"""
def __init__(self,
range: Tuple[float, float] = (-0.5, 0.5),
p: float = 0.5,
input_types=None
):
super().__init__(input_types)
self.minval = range[0]
self.maxval = range[1]
self.probability = p
assert self.minval > -1.0, "Brightness should be in the range (-1.0, 1.0), current minval = {}".format(
self.minval)
assert self.maxval < 1.0, "Brightness should be in the range (-1.0, 1.0), current maxval = {}".format(
self.maxval)
def pixelwise(self, rng: jnp.ndarray, pixel: jnp.ndarray, invert=False) -> jnp.ndarray:
if pixel.dtype != jnp.float32:
raise ValueError(f"RandomContrast can only be applied to float images, but the input is {pixel.dtype}. "
"Please call ByteToFloat first.")
k1, k2 = jax.random.split(rng)
random_contrast = jax.random.uniform(k1, minval=self.minval, maxval=self.maxval)
contrast = jnp.where(jax.random.bernoulli(k2, self.probability), random_contrast, 0.0)
return F.adjust_contrast(pixel, contrast, invert=invert)
class ColorJitter(ColorspaceTransformation):
"""Randomly jitter the image colors.
Args:
range (float, float):
p (float): Probability of applying the transformation
Reference: https://github.com/deepmind/deepmind-research/blob/master/byol/utils/augmentations.py
"""
def __init__(self,
brightness: float = 0.8,
contrast: float = 0.8,
saturation: float = 0.8,
hue: float = 0.2,
p: float = 0.5,
shuffle: bool = True,
input_types=None
):
super().__init__(input_types)
self.brightness = brightness
self.contrast = contrast
self.saturation = saturation
self.hue = hue
self.shuffle = shuffle
self.probability = p
def pixelwise(self, rng: jnp.ndarray, pixel: jnp.ndarray, invert=False) -> jnp.ndarray:
if pixel.shape != (3,):
raise ValueError(f"ColorJitter only supports RGB imagery for now, got {pixel.shape}")
if pixel.dtype != jnp.float32:
raise ValueError(f"ColorJitter can only be applied to float images, but the input is {pixel.dtype}. "
"Please call ByteToFloat first.")
keys = jax.random.split(rng, 4)
hue, saturation, value = rgb_to_hsv(pixel)
ops = ['brightness', 'contrast', 'hue', 'saturation']
if invert:
ops = reversed(ops)
keys = reversed(keys)
# Todo: the order maybe deterministic after jit. Try different implementation
if self.shuffle:
order = np.random.permutation(4)
else:
order = range(4)
for idx in order:
op, key = ops[idx], keys[idx]
strength = getattr(self, op)
if strength <= 0:
continue
if op == 'saturation':
amount = log_uniform(key, minval=1.0 / (1.0 + strength), maxval=1.0 + strength)
else:
amount = jax.random.uniform(key, minval=-strength, maxval=strength)
if op == 'brightness':
value = F.adjust_brightness(value, amount, invert=invert)
elif op == 'contrast':
value = F.adjust_contrast(value, amount, invert=invert)
elif op == 'hue':
if invert:
amount = -amount
hue = (hue + amount) % 1.0
elif op == 'saturation':
if invert:
amount = 1.0 / amount
saturation = jnp.clip(saturation * amount, 0., 1.)
else:
raise ValueError('Unknown operation: {}'.format(op))
transformed = hsv_to_rgb(hue, saturation, value)
if self.probability < 1:
do_apply = jax.random.bernoulli(rng, self.probability)
transformed = jnp.where(do_apply, transformed, pixel)
return transformed
class RandomGrayscale(ColorspaceTransformation):
"""Randomly converts the image to grayscale.
Args:
p (float): Probability of applying the transformation
"""
def __init__(self,
p: float = 0.5,
input_types=None
):
super().__init__(input_types)
self.probability = p
def pixelwise(self, rng: jnp.ndarray, pixel: jnp.ndarray, invert=False) -> jnp.ndarray:
if pixel.dtype != jnp.float32:
raise ValueError(f"RandomGrayscale can only be applied to float images, but the input is {pixel.dtype}. "
"Please call ByteToFloat first.")
if invert:
warnings.warn("Trying to invert a Grayscale Filter, which is not invertible.")
return pixel
do_apply = jax.random.bernoulli(rng, self.probability)
return jnp.where(do_apply,
F.to_grayscale(pixel),
pixel
)
class Solarization(ColorspaceTransformation):
"""Randomly solarizes the image.
Args:
range (float, float):
p (float): Probability of applying the transformation
"""
def __init__(self,
threshold: float = 0.5,
p: float = 0.5,
input_types=None
):
super().__init__(input_types)
self.range = range
self.threshold = threshold
self.probability = p
def pixelwise(self, rng: jnp.ndarray, pixel: jnp.ndarray, invert=False) -> jnp.ndarray:
if pixel.dtype != jnp.float32:
raise ValueError(f"Solarization can only be applied to float images, but the input is {pixel.dtype}. "
"Please call ByteToFloat first.")
if invert:
warnings.warn("Trying to invert a Solarization Filter, which is not invertible.")
return pixel
do_apply = jax.random.bernoulli(rng, self.probability)
solarized = jnp.where((pixel > self.threshold) & do_apply,
1.0 - pixel,
pixel
)
return solarized
| 14,012 | 35.023136 | 118 | py |
RCIG | RCIG-master/augmax/imagelevel.py | # Copyright 2021 Konrad Heidler
#
# 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.
from abc import abstractmethod
from typing import Union, List, Tuple
import math
import jax
import jax.numpy as jnp
import numpy as np
from einops import rearrange
import warnings
from .base import Transformation, InputType, same_type
from .utils import log_uniform
from .functional.dropout import cutout
class ImageLevelTransformation(Transformation):
pass
class GridShuffle(ImageLevelTransformation):
"""Divides the image into grid cells and shuffles them randomly.
Args:
grid_size (int, int): Tuple of `(gridcells_x, gridcells_y)` that specifies into how many
cells the image is to be divided along each axis.
If only a single number is given, that value will be used along both axes.
Currently requires that each image dimension is a multiple of the corresponding value.
p (float): Probability of applying the transformation
"""
def __init__(self, grid_size: Union[Tuple[int, int], int] = (4, 4), p: float = 0.5, input_types=[InputType.IMAGE]):
super().__init__(input_types)
if hasattr(grid_size, '__iter__'):
self.grid_size = tuple(grid_size)
else:
self.grid_size = (self.grid_size, self.grid_size)
self.grid_size = grid_size
self.probability = p
def apply(self, rng: jnp.ndarray, inputs: jnp.ndarray, input_types: List[InputType] = None, invert=False) -> List[
jnp.ndarray]:
if input_types is None:
input_types = self.input_types
key1, key2 = jax.random.split(rng)
do_apply = jax.random.bernoulli(key1, self.probability)
val = []
for input, type in zip(inputs, input_types):
current = None
if same_type(type, InputType.IMAGE) or same_type(type, InputType.MASK) or same_type(type, InputType.DENSE):
raw_image = input
H, W, C = raw_image.shape
gx, gy = self.grid_size
if H % self.grid_size[0] != 0:
raise ValueError(f"Image height ({H}) needs to be a multiple of gridcells_y ({gy})")
if W % self.grid_size[1] != 0:
raise ValueError(f"Image width ({W}) needs to be a multiple of gridcells_x ({gx})")
image = rearrange(raw_image, '(gy h) (gx w) c -> (gy gx) h w c', gx=gx, gy=gy)
if invert:
inv_permutation = jnp.argsort(jax.random.permutation(key2, image.shape[0]))
image = image[inv_permutation]
else:
image = jax.random.permutation(key2, image)
image = rearrange(image, '(gy gx) h w c -> (gy h) (gx w) c', gx=gx, gy=gy)
current = jnp.where(do_apply, image, raw_image)
else:
raise NotImplementedError(f"GridShuffle for {type} not yet implemented")
current = input
val.append(current)
return val
class _ConvolutionalBlur(ImageLevelTransformation):
@abstractmethod
def __init__(self, p: float = 0.5, input_types=[InputType.IMAGE]):
super().__init__(input_types)
self.probability = p
self.kernel = None
self.kernelsize = -1
def apply(self, rng: jnp.ndarray, inputs: jnp.ndarray, input_types: List[InputType] = None, invert=False) -> List[
jnp.ndarray]:
if input_types is None:
input_types = self.input_types
val = []
do_apply = jax.random.bernoulli(rng, self.probability)
p0 = self.kernelsize // 2
p1 = self.kernelsize - p0 - 1
for input, type in zip(inputs, input_types):
current = None
if same_type(type, InputType.IMAGE):
if invert:
warnings.warn("Trying to invert a Blur Filter, which is not invertible.")
current = input
else:
image_padded = jnp.pad(input, [(p0, p1), (p0, p1), (0, 0)], mode='edge')
image_padded = rearrange(image_padded, 'h w (c c2) -> c c2 h w', c2=1)
convolved = jax.lax.conv(image_padded, self.kernel, [1, 1], 'valid')
convolved = rearrange(convolved, 'c c2 h w -> h w (c c2)', c2=1)
current = jnp.where(do_apply, convolved, input)
else:
current = input
val.append(current)
return val
class Blur(_ConvolutionalBlur):
def __init__(self, size: int = 5, p: float = 0.5):
super().__init__(p)
self.kernel = jnp.ones([1, 1, size, size])
self.kernel = self.kernel / self.kernel.sum()
self.kernelsize = size
class GaussianBlur(_ConvolutionalBlur):
def __init__(self, sigma: int = 3, p: float = 0.5):
super().__init__(p)
N = int(math.ceil(2 * sigma))
rng = jnp.linspace(-2.0, 2.0, N)
x = rng.reshape(1, -1)
y = rng.reshape(-1, 1)
self.kernel = jnp.exp((-0.5 / sigma) * (x * x + y * y))
self.kernel = self.kernel / self.kernel.sum()
self.kernel = self.kernel.reshape(1, 1, N, N)
self.kernelsize = N
class Cutout(ImageLevelTransformation):
"""CoarseDropout of the square regions in the image.
Args:
num_holes (int): number of regions to zero out
max_h_size (int): maximum height of the hole
max_w_size (int): maximum width of the hole
fill_value (int, float, list of int, list of float): value for dropped pixels.
Targets:
image
Image types:
uint8, float32
Reference:
| https://github.com/albumentations-team/albumentations/blob/master/albumentations/augmentations/dropout/cutout.py
"""
def __init__(self, num_holes: int = 8,
max_h_size: int = 8,
max_w_size: int = 8,
fill_value: Union[int, float] = 0,
p: float = 0.5):
super().__init__()
self.num_holes = num_holes
self.max_h_size = max_h_size
self.max_w_size = max_w_size
self.fill_value = fill_value
self.probability = p
def apply(self, rng: jnp.ndarray, inputs: jnp.ndarray, input_types: List[InputType] = None, invert=False) -> List[
jnp.ndarray]:
if input_types is None:
input_types = self.input_types
key1, key2 = jax.random.split(rng)
do_apply = jax.random.bernoulli(key1, self.probability)
val = []
for input, type in zip(inputs, input_types):
current = None
if same_type(type, InputType.IMAGE) or same_type(type, InputType.MASK) or same_type(type, InputType.DENSE):
raw_image = input
H, W, C = raw_image.shape
holes = []
for _ in range(self.num_holes):
new_rng, key2 = jax.random.split(key2)
y, x = jax.random.randint(new_rng, [2], minval=jnp.array([0, 0]),
maxval=jnp.array([H - self.max_h_size+1, W - self.max_w_size+1]))
holes.append((x, y, 0))
image = cutout(raw_image, holes, self.fill_value, self.max_w_size, self.max_h_size)
if invert:
warnings.warn("Trying to invert a cutout image, which is not invertible.")
current = raw_image
else:
current = jnp.where(do_apply, image, raw_image)
else:
raise NotImplementedError(f"Cutout for {type} not yet implemented")
val.append(current)
return val
class NormalizedColorJitter(ImageLevelTransformation):
"""Randomly jitter the image colors when the image is normalized.
Args:
range (float, float):
p (float): Probability of applying the transformation
Reference: https://github.com/VICO-UoE/DatasetCondensation/blob/master/utils.py
"""
def __init__(self,
brightness: float = 0.5,
contrast: float = 1.0,
saturation: float = 0.5,
p: float = 0.5,
input_types=None
):
super().__init__(input_types)
self.brightness = brightness
self.contrast = np.exp(contrast) if contrast > 0 else 0.0
self.saturation = np.exp(saturation) if saturation > 0 else 0.0
self.probability = p
def apply(self, rng: jnp.ndarray, inputs: jnp.ndarray, input_types: List[InputType] = None, invert=False) -> List[
jnp.ndarray]:
if input_types is None:
input_types = self.input_types
keys = jax.random.split(rng, 3)
val = []
for input, type in zip(inputs, input_types):
if same_type(type, InputType.IMAGE) or same_type(type, InputType.MASK) or same_type(type, InputType.DENSE):
x = input
ops = ['brightness', 'contrast', 'saturation']
for op, key in zip(ops, keys):
strength = getattr(self, op)
if strength <= 0:
continue
if op == 'brightness':
randb = jax.random.uniform(key, minval=-self.brightness, maxval=self.brightness)
x_new = x + randb
elif op == 'contrast':
randc = log_uniform(key, minval=1 / self.contrast, maxval=self.contrast)
x_mean = x.mean(axis=(-1, -2, -3), keepdims=True)
x_new = (x - x_mean) * randc + x_mean
elif op == 'saturation':
rands = log_uniform(key, minval=1 / self.saturation, maxval=self.saturation)
x_mean = x.mean(axis=-1, keepdims=True)
x_new = (x - x_mean) * rands + x_mean
else:
raise ValueError('Unknown operation: {}'.format(op))
do_apply = jax.random.bernoulli(key, self.probability)
x = jnp.where(do_apply, x_new, x)
if invert:
warnings.warn("Trying to invert a normalized color jittered image, which is not invertible.")
current = x
else:
current = input
val.append(current)
return val | 10,960 | 39.297794 | 119 | py |
RCIG | RCIG-master/augmax/functional/dropout.py | from typing import List, Tuple, Union, Iterable
from functools import wraps
import jax.numpy as jnp
import numpy as np
from jax import lax
__all__ = ["cutout", "channel_dropout"]
def preserve_shape(func):
"""
Preserve shape of the image
"""
@wraps(func)
def wrapped_function(img, *args, **kwargs):
shape = img.shape
result = func(img, *args, **kwargs)
result = result.reshape(shape)
return result
return
@preserve_shape
def channel_dropout(
img: jnp.ndarray, channels_to_drop: Union[int, Tuple[int, ...], jnp.ndarray], fill_value: Union[int, float] = 0
) -> jnp.ndarray:
if len(img.shape) == 2 or img.shape[2] == 1:
raise NotImplementedError("Only one channel. ChannelDropout is not defined.")
img = img.copy()
img[..., channels_to_drop] = fill_value
return img
def cutout(
img: jnp.ndarray, holes: Iterable[Tuple[int, int, int]], fill_value: Union[int, float] = 0, max_w_size: int = 8,
max_h_size: int = 8
) -> jnp.ndarray:
# Make a copy of the input image since we don't want to modify it directly
mask = jnp.ones((max_w_size, max_h_size, img.shape[-1])) * fill_value
for start_indices in holes:
img = lax.dynamic_update_slice(img, mask, start_indices)
return img
# img = img.copy()
# for x1, y1, x2, y2 in holes:
# img[y1:y2, x1:x2] = fill_value
# return img
| 1,423 | 25.867925 | 120 | py |
RCIG | RCIG-master/augmax/functional/colorspace.py | import jax
import jax.numpy as jnp
def identity(value):
return value
def to_grayscale(pixel):
pixel = jnp.broadcast_to(pixel.mean(axis=-1, keepdims=True), pixel.shape)
return pixel
def adjust_brightness(value, brightness, invert=False):
# Invertible brightness transform
# Works for float image [0,1]
# Blend with all one images or all zero image
if not invert:
return jnp.where(brightness < 0.0,
value * (1.0 + brightness),
value * (1.0 - brightness) + brightness
)
else:
return jnp.where(brightness < 0.0,
value / (1.0 + brightness),
(value - brightness) / (1.0 - brightness)
)
def adjust_contrast(value, contrast, invert=False):
# Invertible contrast transform
# Works for float image [0,1]
if invert:
contrast = -contrast
slant = jnp.tan((contrast + 1.0) * (jnp.pi / 4))
# See https://www.desmos.com/calculator/yxnm5siet4
p1 = (slant - jnp.square(slant)) / (2 * (1 - jnp.square(slant)))
p2 = 1 - p1
value = jnp.piecewise(value, [value < p1, value > p2], [
lambda x: x / slant,
lambda x: (x / slant) + 1 - 1 / slant,
lambda x: slant * (x - 0.5) + 0.5
])
return value
| 1,260 | 28.325581 | 77 | py |
SOPE | SOPE-master/ope/base_policy_methods/beat_mountain_car.py | # from pyvirtualdisplay import Display
# display = Display(visible=0, size=(1000, 1000))
# display.start()
# import pdb; pdb.set_trace()
import os
import gym
import matplotlib
matplotlib.use('agg')
from envs.modified_mountain_car import ModifiedMountainCarEnv
import random
import numpy as np
import keras
from keras.models import Sequential
from keras.layers import Dense, Conv2D, Flatten, MaxPool2D
from keras.optimizers import Adam
from tqdm import tqdm
import matplotlib
matplotlib.use('agg')
import matplotlib.pyplot as plt
import time
from skimage.transform import resize
from openai.replay_buffer import ReplayBuffer
from openai.schedules import PiecewiseSchedule
from keras.models import load_model
np.random.seed(0)
FRAMESKIP = 5
FRAMEHEIGHT = 2
class Monitor(object):
def __init__(self, env, filepath):
self.frame_num = 0
self.vid_num = 0
self.filepath = os.path.join(os.getcwd(), filepath)
if not os.path.exists(self.filepath):
os.makedirs(self.filepath)
self.image_name = "image%05d.png"
self.env = env
self.images = []
def save(self):
#import matplotlib.pyplot as plt
full_path = os.path.join(self.filepath, self.image_name % self.frame_num)
self.images.append(full_path)
# plt.imsave(full_path, self.env.render('rgb_array'))
im = self.env.render()
plt.imshow(im, cmap='gray')
#plt.show(block=False)
#plt.pause(.001)
#plt.close()
plt.imsave(full_path, im)
self.frame_num += 1
def make_video(self):
import subprocess
current_dir = os.getcwd()
os.chdir(self.filepath)
# #'ffmpeg -framerate 8 -i image%05d.png -r 30 -pix_fmt yuv420p car_vid_0.mp4'
subprocess.call([
'ffmpeg', '-hide_banner', '-loglevel', 'panic', '-framerate', '8', '-i', self.image_name, '-r', '30', '-pix_fmt', 'yuv420p',
'mc_vid_%s.mp4' % self.vid_num
])
self.vid_num += 1
self.frame_num = 0
os.chdir(current_dir)
def delete(self):
self.frame_num = 0
current_dir = os.getcwd()
os.chdir(self.filepath)
for file_name in [f for f in os.listdir(os.getcwd()) if '.png' in f]:
os.remove(file_name)
os.chdir(current_dir)
#nitor(self.env, 'videos')
def model_data_preparation():
training_data = []
accepted_scores = []
for game_index in tqdm(range(intial_games)):
score = 0
game_memory = []
previous_observation = env.reset()
frames = [previous_observation]*FRAMEHEIGHT
for step_index in range(goal_steps):
action = random.randrange(0, 3)
observation, reward, done, info = env.step(action)
frames.append(observation)
frames.pop(0)
game_memory.append([frames[:FRAMEHEIGHT], frames[1:], action])
previous_observation = observation
if observation[0] > -0.2:
reward = 1
score += reward
if done:
break
if score >= score_requirement:
print(game_index, score)
accepted_scores.append(score)
for data in game_memory:
if data[-1] == 1:
output = [0, 1, 0]
elif data[-1] == 0:
output = [1, 0, 0]
elif data[-1] == 2:
output = [0, 0, 1]
training_data.append([data[0], output])
env.reset()
print(accepted_scores)
return training_data
def build_model(input_size, output_size):
# model = Sequential()
# model.add(Dense(128, input_dim=input_size, activation='relu'))
# model.add(Dense(52, activation='relu'))
# model.add(Dense(output_size, activation='softmax'))
# model.compile(loss='categorical_crossentropy', optimizer=Adam())
inp = keras.layers.Input(input_size, name='frames')
actions = keras.layers.Input((3,), name='mask')
# # "The first hidden layer convolves 16 8×8 filters with stride 4 with the input image and applies a rectifier nonlinearity."
# # conv_1 = keras.layers.convolutional.Convolution2D(
# # 8, 5 , 5, subsample=(4, 4), activation='relu'
# # )(normalized)
# conv1 = Conv2D(64, kernel_size=16, strides=2, activation='relu', data_format='channels_first')(inp)
# #pool1 = MaxPool2D(data_format='channels_first')(conv1)
# conv2 = Conv2D(64, kernel_size=8, strides=2, activation='relu', data_format='channels_first')(conv1)
# #pool2 = MaxPool2D(data_format='channels_first')(conv2)
# conv3 = Conv2D(64, kernel_size=4, strides=2, activation='relu', data_format='channels_first')(conv2)
# #pool3 = MaxPool2D(data_format='channels_first')(conv3)
flat = Flatten()(inp)
dense1 = Dense(256, activation='relu')(flat)
dense2 = Dense(128, activation='relu')(dense1)
out = Dense(output_size, activation='linear', name='all_Q')(dense2)
filtered_output = keras.layers.dot([out, actions], axes=1)
model = keras.models.Model(input=[inp, actions], output=[filtered_output])
all_Q = keras.models.Model(inputs=[inp],
outputs=model.get_layer('all_Q').output)
rmsprop = keras.optimizers.RMSprop(lr=0.0001, rho=0.9, epsilon=None, decay=0.0)
model.compile(loss='mse', optimizer=rmsprop)
# model = Sequential()
# model.add( Conv2D(8, kernel_size=5, strides=5, activation='relu', data_format='channels_first', input_shape=input_size) )
# model.add( Conv2D(8, kernel_size=3, strides=3, activation='relu') )
# model.add( Flatten() )
# model.add( Dense(10, activation='relu') )
# model.add(Dense(10, activation='relu'))
# model.add(Dense(output_size, activation='linear'))
# model.compile(loss='mse', optimizer=Adam())
# model.summary()
return model, all_Q
def train_model(epochs = 5):
arr = env.render()
experience_replay = ReplayBuffer(50000)
greedy_schedule = PiecewiseSchedule([(0,.3), (100, .02), (750, .01)], outside_value = .01)
model, all_Q = build_model(input_size=(FRAMEHEIGHT,2), output_size=3)
model.summary()
target_model, all_Q_target = build_model(input_size=(FRAMEHEIGHT,2), output_size=3)
trained = False
max_timesteps = 200
last_200 = [0]*200
total_t = 0
number_of_episodes = 0
while not trained:
state = env.reset()
frames = [state]*FRAMEHEIGHT
score = 0
t = 0
done = False
while (not done) and (t < max_timesteps):
eps = np.random.random()
if eps < greedy_schedule.value(number_of_episodes):
action = np.random.choice(range(3))
else:
action = np.argmax(all_Q.predict(np.array(frames)[np.newaxis, ...]))
rew = 0
for _ in range(FRAMESKIP):
if done: continue
next_state, reward, done, info = env.step(action)
if next_state[1] > state[1] and next_state[1]>0 and state[1]>0:
reward = -.5
elif next_state[1] < state[1] and next_state[1]<=0 and state[1]<=0:
reward = -.5
# give more reward if the cart reaches the flag in 200 steps
if done:
reward = 1.
rew += reward
rew /= FRAMESKIP
#else:
# # put a penalty if the no of time steps is more
# reward = -1.
frames.append(next_state)
experience_replay.add(np.array(frames[:FRAMEHEIGHT]), action, rew, np.array(frames[1:]), done)
frames.pop(0)
if (total_t % 3000) == 0:
target_model.set_weights(model.get_weights())
if total_t >= 5000:
if (total_t % 20) == 0:
s,a,r,s_,dones = experience_replay.sample(64)
Q_s_ = all_Q_target.predict(s_)
y = r + np.max(Q_s_,axis=1)*(1.-dones.astype(float))
# print(y)
# print(model.predict([s, np.eye(3)[a]]))
# import pdb; pdb.set_trace()
model.fit([s, np.eye(3)[a]], y, verbose=0, epochs= 1)
# print(model.predict([s, np.eye(3)[a]]))
state = next_state
score += rew
t += 1
total_t += 1
if done:
break
number_of_episodes += 1
last_200.append(done)
last_200.pop(0)
print(number_of_episodes, int(score), done, np.mean(last_200))
if np.mean(last_200) > .95:
trained = True
return model, all_Q
def test(model, tests=100, render = False):
model, all_Q = model
scores = []
choices = []
dones = []
mon = Monitor(env, 'videos')
for each_game in tqdm(range(tests)):
score = 0
prev_obs = env.reset()
frames = [prev_obs]*FRAMEHEIGHT
done = False
if render:
mon.save()
#arr = frames[-1]
#plt.imshow(arr)
#plt.show(block=False)
#plt.pause(.001)
#plt.close()
for step_index in range(goal_steps):
action = np.argmax(all_Q.predict(np.array(frames)[np.newaxis, ...]))
choices.append(action)
rew = 0
for _ in range(FRAMESKIP):
if done: continue
new_observation, reward, done, info = env.step(action)
rew += reward
if render: mon.save()
frames.append(new_observation)
frames.pop(0)
rew /= FRAMESKIP
#if render:
#mon.save()
#arr = frames[-1]
#plt.imshow(arr, cmap='gray')
#plt.show(block=False)
#plt.pause(.000001)
#plt.close()
prev_obs = new_observation
score+=rew
if done:
break
mon.make_video()
dones.append(done)
scores.append(score)
return scores, dones, choices
# print(scores)
# print('Average Score:',sum(scores)/len(scores))
# print('choice 1:{} choice 0:{} choice 2:{}'.format(choices.count(1)/len(choices),choices.count(0)/len(choices),choices.count(2)/len(choices)))
env = ModifiedMountainCarEnv() #gym.make('MountainCar-v0')
env.reset()
goal_steps = 200
score_requirement = -198
intial_games = 1000
# training_data = model_data_preparation()
trained_model = train_model(epochs = 5)
trained_model[1].save('mc_trained_model_Q.h5')
trained_model[0].save('mc_trained_model.h5')
# untrained_model = train_model(epochs = 1)
# scores, choices = test(trained_model, tests=100, render = False)
# print(scores)
# print('Average Score:',sum(scores)/len(scores))
# print('choice 1:{} choice 0:{} choice 2:{}'.format(choices.count(1)/len(choices),choices.count(0)/len(choices),choices.count(2)/len(choices)))
trained_model_Q = load_model('mc_trained_model_Q.h5')
trained_model = load_model('mc_trained_model.h5')
_,_,_ = test([trained_model, trained_model_Q], tests=1, render = 1)#False)
#_,_ = test(untrained_model, tests=1, render = True)
#yaml_string = trained_model.to_yaml()
#trained_model.save('car_trained.h5')
import pdb; pdb.set_trace()
| 11,704 | 32.927536 | 149 | py |
SOPE | SOPE-master/ope/base_policy_methods/beat_mountain_car_pixel.py | from pyvirtualdisplay import Display
display = Display(visible=0, size=(1000, 1000))
display.start()
import pdb; pdb.set_trace()
import os
import gym
import matplotlib
matplotlib.use('agg')
from envs.modified_mountain_car import ModifiedMountainCarEnv
import random
import numpy as np
import keras
from keras.models import Sequential
from keras.layers import Dense, Conv2D, Flatten, MaxPool2D
from keras.optimizers import Adam
from tqdm import tqdm
import matplotlib
matplotlib.use('agg')
import matplotlib.pyplot as plt
import time
from skimage.transform import resize
from openai.replay_buffer import ReplayBuffer
from openai.schedules import PiecewiseSchedule
from keras.models import load_model
np.random.seed(0)
# def model_data_preparation_old():
# training_data = []
# accepted_scores = []
# for game_index in tqdm(range(intial_games)):
# score = 0
# game_memory = []
# previous_observation = env.reset()
# for step_index in range(goal_steps):
# action = random.randrange(0, 3)
# observation, reward, done, info = env.step(action)
# if len(previous_observation) > 0:
# game_memory.append([previous_observation, action])
# previous_observation = observation
# if observation[0] > -0.2:
# reward = 1
# score += reward
# if done:
# break
# if score >= score_requirement:
# accepted_scores.append(score)
# for data in game_memory:
# if data[1] == 1:
# output = [0, 1, 0]
# elif data[1] == 0:
# output = [1, 0, 0]
# elif data[1] == 2:
# output = [0, 0, 1]
# training_data.append([data[0], output])
# env.reset()
# print(accepted_scores)
# return training_data
# def test_old(model, tests=100, render = False):
# scores = []
# choices = []
# for each_game in tqdm(range(tests)):
# score = 0
# prev_obs = env.reset()
# for step_index in range(goal_steps):
# # Uncomment this line if you want to see how our bot playing
# if render:
# arr = env.render()
# plt.imshow(arr)
# plt.show(block=False)
# plt.pause(.001)
# plt.close()
# action = np.argmax(model.predict(prev_obs.reshape(-1, len(prev_obs)))[0])
# choices.append(action)
# new_observation, reward, done, info = env.step(action)
# prev_obs = new_observation
# score+=reward
# if done:
# break
# scores.append(score)
# return scores, choices
# # print(scores)
# # print('Average Score:',sum(scores)/len(scores))
# # print('choice 1:{} choice 0:{} choice 2:{}'.format(choices.count(1)/len(choices),choices.count(0)/len(choices),choices.count(2)/len(choices)))
FRAMESKIP = 2
class Monitor(object):
def __init__(self, env, filepath):
self.frame_num = 0
self.vid_num = 0
self.filepath = os.path.join(os.getcwd(), filepath)
if not os.path.exists(self.filepath):
os.makedirs(self.filepath)
self.image_name = "image%05d.png"
self.env = env
self.images = []
def save(self):
#import matplotlib.pyplot as plt
full_path = os.path.join(self.filepath, self.image_name % self.frame_num)
self.images.append(full_path)
# plt.imsave(full_path, self.env.render('rgb_array'))
im = self.env.render()
plt.imshow(im, cmap='gray')
#plt.show(block=False)
#plt.pause(.001)
#plt.close()
plt.imsave(full_path, im)
self.frame_num += 1
def make_video(self):
import subprocess
current_dir = os.getcwd()
os.chdir(self.filepath)
# #'ffmpeg -framerate 8 -i image%05d.png -r 30 -pix_fmt yuv420p car_vid_0.mp4'
subprocess.call([
'ffmpeg', '-hide_banner', '-loglevel', 'panic', '-framerate', '8', '-i', self.image_name, '-r', '30', '-pix_fmt', 'yuv420p',
'car_vid_%s.mp4' % self.vid_num
])
self.vid_num += 1
self.frame_num = 0
os.chdir(current_dir)
def delete(self):
self.frame_num = 0
current_dir = os.getcwd()
os.chdir(self.filepath)
for file_name in [f for f in os.listdir(os.getcwd()) if '.png' in f]:
os.remove(file_name)
os.chdir(current_dir)
#nitor(self.env, 'videos')
def to_gray(arr):
if len(arr.shape) == 2:
return arr
else:
return np.dot(arr[...,:3]/255. , [0.299, 0.587, 0.114])
def model_data_preparation():
training_data = []
accepted_scores = []
for game_index in tqdm(range(intial_games)):
score = 0
game_memory = []
previous_observation = env.reset()
frames = [to_gray(env.render())]*FRAMESKIP
for step_index in range(goal_steps):
action = random.randrange(0, 3)
observation, reward, done, info = env.step(action)
frames.append(to_gray(env.render()))
frames.pop(0)
game_memory.append([frames[:2], frames[1:], action])
previous_observation = observation
if observation[0] > -0.2:
reward = 1
score += reward
if done:
break
if score >= score_requirement:
print(game_index, score)
accepted_scores.append(score)
for data in game_memory:
if data[-1] == 1:
output = [0, 1, 0]
elif data[-1] == 0:
output = [1, 0, 0]
elif data[-1] == 2:
output = [0, 0, 1]
training_data.append([data[0], output])
env.reset()
print(accepted_scores)
return training_data
def build_model(input_size, output_size):
# model = Sequential()
# model.add(Dense(128, input_dim=input_size, activation='relu'))
# model.add(Dense(52, activation='relu'))
# model.add(Dense(output_size, activation='softmax'))
# model.compile(loss='categorical_crossentropy', optimizer=Adam())
inp = keras.layers.Input(input_size, name='frames')
actions = keras.layers.Input((3,), name='mask')
# "The first hidden layer convolves 16 8×8 filters with stride 4 with the input image and applies a rectifier nonlinearity."
# conv_1 = keras.layers.convolutional.Convolution2D(
# 8, 5 , 5, subsample=(4, 4), activation='relu'
# )(normalized)
conv1 = Conv2D(64, kernel_size=16, strides=2, activation='relu', data_format='channels_first')(inp)
#pool1 = MaxPool2D(data_format='channels_first')(conv1)
conv2 = Conv2D(64, kernel_size=8, strides=2, activation='relu', data_format='channels_first')(conv1)
#pool2 = MaxPool2D(data_format='channels_first')(conv2)
conv3 = Conv2D(64, kernel_size=4, strides=2, activation='relu', data_format='channels_first')(conv2)
#pool3 = MaxPool2D(data_format='channels_first')(conv3)
flat = Flatten()(conv3)
dense1 = Dense(10, activation='relu')(flat)
dense2 = Dense(30, activation='relu')(dense1)
out = Dense(output_size, activation='linear', name='all_Q')(dense2)
filtered_output = keras.layers.dot([out, actions], axes=1)
model = keras.models.Model(input=[inp, actions], output=[filtered_output])
all_Q = keras.models.Model(inputs=[inp],
outputs=model.get_layer('all_Q').output)
rmsprop = keras.optimizers.RMSprop(lr=0.0001, rho=0.9, epsilon=None, decay=0.0)
model.compile(loss='mse', optimizer=rmsprop)
# model = Sequential()
# model.add( Conv2D(8, kernel_size=5, strides=5, activation='relu', data_format='channels_first', input_shape=input_size) )
# model.add( Conv2D(8, kernel_size=3, strides=3, activation='relu') )
# model.add( Flatten() )
# model.add( Dense(10, activation='relu') )
# model.add(Dense(10, activation='relu'))
# model.add(Dense(output_size, activation='linear'))
# model.compile(loss='mse', optimizer=Adam())
# model.summary()
return model, all_Q
def train_model(epochs = 5):
arr = env.render()
experience_replay = ReplayBuffer(50000)
greedy_schedule = PiecewiseSchedule([(0,.3), (500, .1), (750, .01)], outside_value = .01)
model, all_Q = build_model(input_size=(2,) + arr.shape, output_size=3)
model.summary()
target_model, all_Q_target = build_model(input_size=(2,) + arr.shape, output_size=3)
trained = False
max_timesteps = 200
last_200 = [0]*200
total_t = 0
number_of_episodes = 0
frame_skip = FRAMESKIP
while not trained:
state = env.reset()
frames = [to_gray(env.render())]*FRAMESKIP
score = 0
t = 0
done = False
while (not done) and (t < max_timesteps):
eps = np.random.random()
if eps < greedy_schedule.value(number_of_episodes):
action = np.random.choice(range(3))
else:
action = np.argmax(all_Q.predict(np.array(frames)[np.newaxis, ...]))
rew = 0
for _ in range(frame_skip):
if done: continue
next_state, reward, done, info = env.step(action)
if next_state[1] > state[1] and next_state[1]>0 and state[1]>0:
reward = -.5
elif next_state[1] < state[1] and next_state[1]<=0 and state[1]<=0:
reward = -.5
# give more reward if the cart reaches the flag in 200 steps
if done:
reward = 1.
rew += reward
rew /= frame_skip
#else:
# # put a penalty if the no of time steps is more
# reward = -1.
frames.append(to_gray(env.render()))
experience_replay.add(np.array(frames[:2]), action, rew, np.array(frames[1:]), done)
frames.pop(0)
if (total_t % 3000) == 0:
target_model.set_weights(model.get_weights())
if total_t >= 5000:
if (total_t % 20) == 0:
s,a,r,s_,dones = experience_replay.sample(64)
Q_s_ = all_Q_target.predict(s_)
y = r + np.max(Q_s_,axis=1)*(1.-dones.astype(float))
# print(y)
# print(model.predict([s, np.eye(3)[a]]))
# import pdb; pdb.set_trace()
model.fit([s, np.eye(3)[a]], y, verbose=0, epochs= 1)
# print(model.predict([s, np.eye(3)[a]]))
state = next_state
score += rew
t += 1
total_t += 1
if done:
break
number_of_episodes += 1
last_200.append(done)
last_200.pop(0)
print(number_of_episodes, int(score), done, np.mean(last_200))
if np.mean(last_200) > .95:
import pdb ;pdb.set_trace()
trained = True
return model, all_Q
def test(model, tests=100, render = False):
frame_skip = 2
model, all_Q = model
scores = []
choices = []
dones = []
mon = Monitor(env, 'videos')
for each_game in tqdm(range(tests)):
score = 0
prev_obs = env.reset()
frames = [to_gray(env.render())]*FRAMESKIP
done = False
if render:
mon.save()
#arr = frames[-1]
#plt.imshow(arr)
#plt.show(block=False)
#plt.pause(.001)
#plt.close()
for step_index in range(goal_steps):
action = np.argmax(all_Q.predict(np.array(frames)[np.newaxis, ...]))
choices.append(action)
rew = 0
for _ in range(frame_skip):
if done: continue
new_observation, reward, done, info = env.step(action)
rew += reward
if render: mon.save()
frames.append(to_gray(env.render()))
frames.pop(0)
rew /= frame_skip
#if render:
#mon.save()
#arr = frames[-1]
#plt.imshow(arr, cmap='gray')
#plt.show(block=False)
#plt.pause(.000001)
#plt.close()
prev_obs = new_observation
score+=rew
if done:
break
mon.make_video()
dones.append(done)
scores.append(score)
return scores, dones, choices
# print(scores)
# print('Average Score:',sum(scores)/len(scores))
# print('choice 1:{} choice 0:{} choice 2:{}'.format(choices.count(1)/len(choices),choices.count(0)/len(choices),choices.count(2)/len(choices)))
env = ModifiedMountainCarEnv() #gym.make('MountainCar-v0')
env.reset()
goal_steps = 200
score_requirement = -198
intial_games = 1000
# training_data = model_data_preparation()
# trained_model = train_model(epochs = 5)
#untrained_model = train_model(epochs = 1)
# scores, choices = test(trained_model, tests=100, render = False)
# print(scores)
# print('Average Score:',sum(scores)/len(scores))
# print('choice 1:{} choice 0:{} choice 2:{}'.format(choices.count(1)/len(choices),choices.count(0)/len(choices),choices.count(2)/len(choices)))
trained_model_Q = load_model('trained_model_Q.h5')
trained_model = load_model('trained_model.h5')
_,_,_ = test([trained_model, trained_model_Q], tests=1, render = 1)#False)
#_,_ = test(untrained_model, tests=1, render = True)
#yaml_string = trained_model.to_yaml()
#trained_model.save('car_trained.h5')
import pdb; pdb.set_trace()
| 14,209 | 32.200935 | 151 | py |
SOPE | SOPE-master/ope/models/approximate_model.py | import numpy as np
import scipy.signal as signal
import keras
from keras.models import Sequential
from keras.layers import Dense, Conv2D, Flatten, MaxPool2D, concatenate, UpSampling2D, Reshape, Lambda, Conv2DTranspose
from keras.optimizers import Adam
from keras import backend as K
import tensorflow as tf
from keras.models import load_model
from keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
from ope.utls.thread_safe import threadsafe_generator
import os
from keras import regularizers
import time
from copy import deepcopy
from sklearn.linear_model import LinearRegression, LogisticRegression
class ApproxModel(object):
def __init__(self, gamma, filename, max_traj_length=None, frameskip=2, frameheight=2, processor=None, action_space_dim=3):
self.gamma = gamma
self.filename = filename
self.override_done = True if max_traj_length is not None else False
self.max_traj_length = 200 if (max_traj_length is None) else max_traj_length
self.frameskip = frameskip
self.frameheight = frameheight
self.action_space_dim = action_space_dim
self.processor = processor
@staticmethod
def sample(transitions, N):
idxs = np.random.choice(np.arange(len(transitions)), size=N)
return transitions[idxs]
def create_T_model(self, input_size):
inp = keras.layers.Input(input_size, name='frames')
actions = keras.layers.Input((self.action_space_dim,), name='mask')
def init(): return keras.initializers.TruncatedNormal(mean=0.0, stddev=0.001, seed=np.random.randint(2**32))
# conv1 = Conv2D(32, kernel_size=16, strides=1, activation='elu', data_format='channels_first', padding='same')(inp)
# pool1 = MaxPool2D((2,2), data_format='channels_first')(conv1)
# conv2 = Conv2D(64, kernel_size=8, strides=1, activation='elu', data_format='channels_first', padding='same')(pool1)
# pool2 = MaxPool2D((2,2), data_format='channels_first')(conv2)
# conv3 = Conv2D(128, kernel_size=4, strides=1, activation='elu', data_format='channels_first', padding='same')(pool2)
# # # pool3 = MaxPool2D((2,2), data_format='channels_first')(conv3)
# # # flat = Flatten()(pool3)
# # # concat = concatenate([flat, actions], axis = -1)
# # # dense1 = Dense(10, activation='relu')(concat)
# # # dense2 = Dense(20, activation='relu')(dense1)
# # # dense3 = Dense(int(np.prod(pool3.shape[1:])), activation='relu')(dense2)
# # # unflatten = Reshape((int(x) for x in pool3.shape[1:]))(dense3)
# conv4 = Conv2D(128, kernel_size=4, strides=1, activation='elu', data_format='channels_first', padding='same')(conv3)
# up1 = UpSampling2D((2,2), data_format='channels_first')(conv4)
# conv5 = Conv2D(64, kernel_size=8, strides=1, activation='elu', data_format='channels_first', padding='same')(up1)
# up2 = UpSampling2D((2,2), data_format='channels_first')(conv5)
# out = Conv2D(self.action_space_dim, kernel_size=16, strides=1, activation='linear', data_format='channels_first', padding='same', name='T')(up2)
conv1 = Conv2D(8, (7,7), strides=(4,4), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(inp)
pool1 = MaxPool2D(data_format='channels_first')(conv1)
conv2 = Conv2D(16, (3,3), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(pool1)
conv3 = Conv2DTranspose(16, (3, 3), strides=(1, 1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(conv2)
up1 = UpSampling2D(data_format='channels_first')(conv3)
out = Conv2DTranspose(self.action_space_dim, (7,7), strides=(4,4), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6), name='T')(up1)
def filter_out(out):
filtered_output = tf.boolean_mask(out, actions, axis = 0)
filtered_output = K.expand_dims(filtered_output, axis=1)
return filtered_output
filtered_output = Lambda(filter_out)(out)
# model = keras.models.Model(input=[inp, actions], output=[out])
model = keras.models.Model(input=[inp, actions], output=[filtered_output])
all_T = keras.models.Model(inputs=[inp],
outputs=model.get_layer('T').output)
rmsprop = keras.optimizers.RMSprop(lr=0.0001, rho=0.9, epsilon=None, decay=0.0, clipnorm=1.)
model.compile(loss='mse', optimizer=rmsprop)
return model, all_T
def create_full_model(self, input_size):
inp = keras.layers.Input(input_size, name='frames')
actions = keras.layers.Input((self.action_space_dim,), name='mask')
def init(): return keras.initializers.TruncatedNormal(mean=0.0, stddev=0.001, seed=np.random.randint(2**32))
if self.modeltype == 'conv':
# Compress
conv1 = Conv2D(8, (7,7), strides=(2,2), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(inp)
conv2 = Conv2D(16, (5,5), strides=(2,2), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(conv1)
conv3 = Conv2D(32, (3,3), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(conv2)
flat = Flatten()(conv3)
# Transition
conv4 = Conv2DTranspose(32, (3, 3), strides=(1, 1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(conv3)
# up1 = UpSampling2D(data_format='channels_first')(conv4)
conv5 = Conv2DTranspose(16, (5,5), strides=(2,2), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(conv4)
out_T = Conv2DTranspose(self.action_space_dim, (7,7), strides=(2,2), padding='same', data_format='channels_first', activation='tanh',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6), name='all_T')(conv5)
# Rewards
dense1 = Dense(10, activation='relu')(flat)
dense2 = Dense(30, activation='relu')(dense1)
out_R = Dense(self.action_space_dim, activation='linear', name='all_R')(dense2)
# Dones
dense3 = Dense(10, activation='relu')(flat)
dense4 = Dense(30, activation='relu')(dense3)
out_D = Dense(self.action_space_dim, activation='softmax', name='all_D')(dense4)
elif self.modeltype == 'conv1':
# Compress
conv1 = Conv2D(16, (3,3), strides=(2,2), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(inp)
conv2 = Conv2D(16, (2,2), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(conv1)
conv3 = Conv2D(16, (2,2), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(conv2)
flat = Flatten()(conv3)
# Transition
conv4 = Conv2DTranspose(16, (2, 2), strides=(1, 1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(conv3)
# up1 = UpSampling2D(data_format='channels_first')(conv4)
conv5 = Conv2DTranspose(16, (2,2), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(conv4)
out_T = Conv2DTranspose(self.action_space_dim, (2,2), strides=(2,2), padding='same', data_format='channels_first', activation='tanh',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6), name='all_T')(conv5)
# Rewards
dense1 = Dense(5, activation='relu')(flat)
dense2 = Dense(10, activation='relu')(dense1)
out_R = Dense(self.action_space_dim, activation='linear', name='all_R')(dense2)
# Dones
dense3 = Dense(5, activation='relu')(flat)
dense4 = Dense(10, activation='relu')(dense3)
out_D = Dense(self.action_space_dim, activation='softmax', name='all_D')(dense4)
else:
# Compress
flat = Flatten()(inp)
dense1 = Dense(128, activation='relu')(flat)
dense2 = Dense(32, activation='relu')(dense1)
# dense3 = Dense(128, activation='relu')(dense2)
out = Dense(2*self.action_space_dim, activation='linear')(dense2)
out_T = Reshape((-1,2), name='all_T')(out)
# Rewards
dense4 = Dense(8, activation='relu')(dense1)
out_R = Dense(self.action_space_dim, activation='linear', name='all_R')(dense2)
# Dones
dense5 = Dense(8, activation='relu')(dense1)
out_D = Dense(self.action_space_dim, activation='softmax', name='all_D')(dense4)
def filter_out(out):
filtered_output = tf.boolean_mask(out, actions, axis = 0)
filtered_output = K.expand_dims(filtered_output, axis=1)
return filtered_output
filtered_T = Lambda(filter_out, name='T')(out_T)
filtered_R = Lambda(filter_out, name='R')(out_R)
filtered_D = Lambda(filter_out, name='D')(out_D)
# model = keras.models.Model(input=[inp, actions], output=[out])
losses = {
"T": "mse",
"R": "mse",
"D": "binary_crossentropy",
}
model = keras.models.Model(input=[inp, actions], output=[filtered_T, filtered_R, filtered_D])
all_model = keras.models.Model(inputs=[inp],
outputs=[model.get_layer('all_T').output, model.get_layer('all_R').output, model.get_layer('all_D').output])
# rmsprop = keras.optimizers.RMSprop(lr=0.0001, rho=0.9, epsilon=None, decay=0.0, clipnorm=1.)
model.compile(loss=losses, optimizer='Adam')
return model, all_model
def create_scalar_model(self, input_size, is_R=True):
inp = keras.layers.Input(input_size, name='frames')
actions = keras.layers.Input((self.action_space_dim,), name='mask')
# "The first hidden layer convolves 16 8×8 filters with stride 4 with the input image and applies a rectifier nonlinearity."
# conv_1 = keras.layers.convolutional.Convolution2D(
# 8, 5 , 5, subsample=(4, 4), activation='relu'
# )(normalized)
conv1 = Conv2D(64, kernel_size=16, strides=2, activation='relu', data_format='channels_first')(inp)
#pool1 = MaxPool2D(data_format='channels_first')(conv1)
conv2 = Conv2D(64, kernel_size=8, strides=2, activation='relu', data_format='channels_first')(conv1)
#pool2 = MaxPool2D(data_format='channels_first')(conv2)
conv3 = Conv2D(64, kernel_size=4, strides=2, activation='relu', data_format='channels_first')(conv2)
#pool3 = MaxPool2D(data_format='channels_first')(conv3)
flat = Flatten()(conv3)
dense1 = Dense(10, activation='relu')(flat)
dense2 = Dense(30, activation='relu')(dense1)
out = Dense(self.action_space_dim, activation='sigmoid', name='all_')(dense2)
filtered_output = keras.layers.dot([out, actions], axes=1)
model = keras.models.Model(input=[inp, actions], output=[filtered_output])
all_ = keras.models.Model(inputs=[inp],
outputs=model.get_layer('all_').output)
rmsprop = keras.optimizers.RMSprop(lr=0.0001, rho=0.9, epsilon=None, decay=0.0, clipnorm=1.)
if is_R:
model.compile(loss='mse', optimizer=rmsprop)
else:
model.compile(loss='binary_crossentropy', optimizer=rmsprop)
return model, all_
@threadsafe_generator
def T_gen(self, env, data, batchsize=32):
frameskip = self.frameheight #lazy
num_batches = int(np.ceil(data.shape[0] / batchsize))
while True:
permutation = np.random.permutation(np.arange(len(data)))
data = data[permutation]
for batch_idx in np.arange(num_batches):
low_ = batch_idx * batchsize
high_ = (1+batch_idx) * batchsize
batch = data[low_:high_]
x = batch[:,:frameskip]
act = batch[:, frameskip].astype(int)
x_ = batch[:, (frameskip+1):]
inp = env.pos_to_image(x)
out = np.diff(env.pos_to_image(x_), axis=1)
yield [inp, np.eye(env.n_actions)[act]], out
@threadsafe_generator
def D_gen(self, env, data, batchsize=32):
frameskip = self.frameheight #lazy
num_batches = int(np.ceil(data.shape[0] / batchsize))
while True:
permutation = np.random.permutation(np.arange(len(data)))
data = data[permutation]
for batch_idx in np.arange(num_batches):
low_ = batch_idx * batchsize
high_ = (1+batch_idx) * batchsize
batch = data[low_:high_]
x_pre = batch[:,:frameskip]
act = batch[:, frameskip].astype(int)
x__pre = batch[:, (frameskip+1):-1]
done = batch[:, -1].astype(int)
x = env.pos_to_image(x_pre)
x_ = env.pos_to_image(x__pre)
inp = np.concatenate([x, x_], axis=1)
out = done
yield [inp, np.eye(env.n_actions)[act]], out
@threadsafe_generator
def R_gen(self, env, data, batchsize=32):
frameskip = self.frameheight #lazy
num_batches = int(np.ceil(data.shape[0] / batchsize))
while True:
permutation = np.random.permutation(np.arange(len(data)))
data = data[permutation]
for batch_idx in np.arange(num_batches):
low_ = batch_idx * batchsize
high_ = (1+batch_idx) * batchsize
batch = data[low_:high_]
x = batch[:,:frameskip]
act = batch[:, frameskip].astype(int)
r = batch[:, (frameskip+1)]
inp = env.pos_to_image(x)
out = -r
yield [inp, np.eye(env.n_actions)[act]], out
@threadsafe_generator
def full_gen(self, env, all_idxs, batch_size=32):
data_length = len(all_idxs)
steps = int(np.ceil(data_length/float(batch_size)))
states = self.data.states()
states_ = self.data.next_states()
lengths = self.data.lengths()
rewards = self.data.rewards().reshape(-1)
actions = self.data.actions().reshape(-1)
dones = self.data.dones().reshape(-1)
shp = states.shape
states = states.reshape(np.prod(shp[:2]), -1)
states_ = states_.reshape(np.prod(shp[:2]), -1)
while True:
perm = np.random.permutation(all_idxs)
for batch in np.arange(steps):
batch_idxs = perm[(batch*batch_size):((batch+1)*batch_size)]
x = states[batch_idxs]
x_ = states_[batch_idxs]
r = rewards[batch_idxs]
done = dones[batch_idxs]
act = actions[batch_idxs]
if self.modeltype in ['conv']:
tmp_shp = np.hstack([len(batch_idxs),-1,shp[2:]])
inp = self.processor(x.reshape(tmp_shp).squeeze())
out_x_ = np.diff(self.processor(x_.reshape(tmp_shp)).squeeze(), axis=1)[:,[-1],...]
out_r = -r
out_done = done
elif self.modeltype == 'conv1':
tmp_shp = np.hstack([len(batch_idxs),-1,shp[2:]])
inp = self.processor(x.reshape(tmp_shp).squeeze())
inp = inp[:,None,:,:]
out_x_ = np.squeeze((x_-x).reshape(tmp_shp))
out_x_ = out_x_[:,None,:,:]
out_r = -r
out_done = done
else:
tmp_shp = np.hstack([len(batch_idxs),-1,shp[2:]])
inp = np.squeeze(x.reshape(tmp_shp))
out_x_ = x_
out_x_ = np.diff(out_x_.reshape(tmp_shp), axis=2).reshape(-np.prod(tmp_shp[:2]), -1)
out_r = -r
out_done = done
out_x_ = out_x_[:,None,...]
yield [inp, np.eye(env.n_actions)[act]], [out_x_, out_r, out_done]
# yield ([x, np.eye(3)[acts], np.array(weight).reshape(-1,1)], [np.array(R).reshape(-1,1)])
@staticmethod
def compare(num_batches_val,val_gen,model):
g = []
for j in range(num_batches_val):
x, y = next(val_gen)
arr = []
for i in range(len(y)):
arr.append(np.mean(np.mean((model.predict(x)[i] - y[i])**2, axis=-1)))
g.append(arr)
return g
def run(self, env, dataset, num_epochs=100, batchsize=32, modeltype='conv'):
'''
Fit NN to transitions, rewards, and done
'''
# Fit P(s' | s,a)
# Do this by change in pixels.
self.modeltype = modeltype
if self.modeltype in ['conv', 'mlp', 'conv1']:
im = dataset.states()[0]
if self.processor: im = self.processor(im)
input_shape = im.shape[1:]#(self.frameheight, 2)
full, full_all = self.create_full_model(input_shape)
earlyStopping = EarlyStopping(monitor='val_loss', min_delta=1e-4, patience=5, verbose=1, mode='min', restore_best_weights=True)
reduce_lr_loss = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=3, verbose=1, min_delta=1e-4, mode='min')
self.data = dataset
dataset_length = self.data.num_tuples()
perm = np.random.permutation(range(dataset_length))
eighty_percent_of_set = int(.8*len(perm))
training_idxs = perm[:eighty_percent_of_set]
validation_idxs = perm[eighty_percent_of_set:]
training_steps_per_epoch = int(1.*np.ceil(len(training_idxs)/float(batchsize)))
validation_steps_per_epoch = int(np.ceil(len(validation_idxs)/float(batchsize)))
train_gen = self.full_gen(env, training_idxs, batchsize)
val_gen = self.full_gen(env, validation_idxs, batchsize)
hist = full.fit_generator(train_gen,
steps_per_epoch=training_steps_per_epoch,
validation_data=val_gen,
validation_steps=validation_steps_per_epoch,
epochs=num_epochs,
callbacks=[earlyStopping, reduce_lr_loss],
max_queue_size=1,
workers=1,
use_multiprocessing=False, )
# try:
# print('Loading Full Model')
# full.load_weights(os.path.join(os.getcwd(), self.filename,'full.h5'))
# except:
# print('Failed to load. Relearning')
# earlyStopping = EarlyStopping(monitor='val_loss', min_delta=1e-4, patience=7, verbose=1, mode='min', restore_best_weights=True)
# # mcp_save = ModelCheckpoint('T.hdf5', save_best_only=True, monitor='val_loss', mode='min')
# reduce_lr_loss = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=4, verbose=1, min_delta=1e-5, mode='min')
# hist = full.fit_generator(train_gen,
# steps_per_epoch=num_batches_train,
# validation_data=val_gen,
# validation_steps=num_batches_val,
# epochs=num_epochs,
# callbacks=[earlyStopping, reduce_lr_loss],
# max_queue_size=1,
# workers=4,
# use_multiprocessing=False, )
# full.save_weights(os.path.join(os.getcwd(), self.filename,'full.h5'))
else: # Linear
x = dataset.states()
act = dataset.actions().reshape(-1)
r = dataset.rewards().reshape(-1)
x_ = dataset.next_states()
done = dataset.dones().reshape(-1)
inp = x.reshape(np.prod(x.shape[:2]), -1)
out_x_ = np.diff(x_, axis=2)
out_x_ = out_x_.reshape(np.prod(out_x_.shape[:2]), -1)
out_r = -r.reshape(-1)
out_done = done.reshape(-1)
X = np.hstack([inp, np.eye(3)[act]])
full_T = LinearRegression().fit(X, out_x_)
full_R = LinearRegression().fit(X, out_r)
full_D = LogisticRegression().fit(X, out_done)
full = [full_T, full_R, full_D]
self.full = full
return self
def estimate_R(self, x, a, t):
#Approximated rewards
reward = -self.R.predict([x,a]).reshape(-1)
return reward
def estimate_R_all(self, x):
return -self.R_all.predict([x])
def old_transition(self, x, a):
# Exact MDP dynamics
# self.P = {(0, 0): {0: 0.5, 1: 0.5}, (0, 1): {0: 0.5, 1: .5}}
#Approximated dynamics
# if tuple([x,a]) in self.P:
# try:
# state = np.random.choice(list(self.P[(x,a)]), p=list(self.P[(x,a)].values()))
# if self.override_done:
# done = False
# else:
# done = np.random.choice(list(self.D[(x,a,state)]),
# p=list(self.D[(x,a,state)].values()))
# except:
# import pdb; pdb.set_trace()
# else:
# state = None
# done = True
state_diff = self.T.predict([x, a])
x_ = np.concatenate([x[:,1:2,...], x[:,1:2,...] + state_diff], axis=1)
prob_done = self.D.predict([np.concatenate([x, x_], axis=1), a])
done = np.array([np.random.choice([0,1], p=[1-d[0], d[0]]) for d in prob_done])
return x_, done
def transition(self, x, a):
if isinstance(self.full, list):
state_diff, r, prob_done = [model.predict(np.hstack([x.reshape(x.shape[0],-1), a])) for model in self.full]
state_diff = state_diff[:,None,:]
prob_done = [[d] for d in prob_done]
else:
[state_diff, r, prob_done] = self.full.predict([x, a], batch_size=128)
x_ = np.concatenate([x[:,1:self.frameheight,...], x[:,(self.frameheight-1):self.frameheight,...] + state_diff], axis=1)
done = np.array([np.random.choice([0,1], p=[1-d[0], d[0]]) for d in prob_done])
return x_, -r.reshape(-1), done
def Q(self, policy, x, t=0):
Qs = []
# state = x
# make action agnostic.
state = np.repeat(x, self.action_space_dim, axis=0)
acts = np.tile(np.arange(self.action_space_dim), len(x))
done = np.zeros(len(state))
costs = []
trajectory_length = t
# Q
cost_to_go = np.zeros(len(state))
new_state, cost_holder, new_done = self.transition(state, np.atleast_2d(np.eye(self.action_space_dim)[acts]))
# cost_holder = self.estimate_R(state, np.atleast_2d(np.eye(self.action_space_dim)[acts]), None)
done = done + new_done
new_cost_to_go = cost_to_go + self.gamma * cost_holder * (1-done)
norm_change = np.sqrt(np.sum((new_cost_to_go-cost_to_go)**2) / len(state))
# print(trajectory_length, norm_change, cost_to_go, sum(done), len(done))
cost_to_go = new_cost_to_go
if norm_change < 1e-4:
done = np.array([True])
trajectory_length += 1
if self.max_traj_length is not None:
if trajectory_length >= self.max_traj_length:
done = np.array([True])
state = new_state
while not done.all():
tic=time.time()
still_alive = np.where(1-done)[0]
acts = policy.sample(state[still_alive])
new_state, cost_holder, new_done = self.transition(state[still_alive], np.atleast_2d(np.eye(self.action_space_dim)[acts]))
# cost_holder = self.estimate_R(state, np.atleast_2d(np.eye(self.action_space_dim)[acts]), trajectory_length)
# if (tuple([state,a,new_state]) in self.terminal_transitions):
# done = True
done[still_alive] = (done[still_alive] + new_done).astype(bool)
new_cost_to_go = cost_to_go[still_alive] + self.gamma * cost_holder * (1-done[still_alive])
# norm_change = np.sqrt(np.sum((new_cost_to_go-cost_to_go)**2) / len(state))
# print(trajectory_length, norm_change, cost_to_go, sum(done), len(done))
cost_to_go[still_alive] = new_cost_to_go
# if norm_change < 1e-4:
# done = np.array([True])
trajectory_length += 1
if self.max_traj_length is not None:
if trajectory_length >= self.max_traj_length:
done = np.array([True])
# print(time.time()-tic, trajectory_length)
state[still_alive] = new_state
return cost_to_go
@staticmethod
def discounted_sum(costs, discount):
'''
Calculate discounted sum of costs
'''
y = signal.lfilter([1], [1, -discount], x=costs[::-1])
return y[::-1][0]
| 26,700 | 45.598604 | 259 | py |
SOPE | SOPE-master/ope/models/conv.py | import torch
import torch.nn as nn
import numpy as np
class defaultCNN(nn.Module):
def __init__(self, shape, action_space_dim):
super(defaultCNN, self).__init__()
self.c, self.h, self.w = shape
self.net = nn.Sequential(
nn.Conv2d(self.c, 16, (2,2)),
nn.ELU(),
nn.Flatten(),
nn.Linear(16*(self.h-1)*(self.w-1), 8),
nn.ELU(),
nn.Linear(8, 8),
nn.ELU(),
nn.Linear(8, action_space_dim)
)
@staticmethod
def weight_init(m):
if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):
torch.nn.init.normal_(m.weight, mean=0.0, std=.001)
torch.nn.init.normal_(m.bias, mean=0.0, std=.001)
def forward(self, state, action):
output = self.net(state)
return torch.masked_select(output, action)
def predict(self, state):
return self.net(state)
def predict_w_softmax(self, state):
return nn.Softmax()(self.net(state))
class defaultModelBasedCNN(nn.Module):
def __init__(self, shape, action_space_dim):
super(defaultModelBasedCNN, self).__init__()
self.c, self.h, self.w = shape
self.features = nn.Sequential(
nn.Conv2d(self.c, 4, (5, 5)),
nn.ELU(),
nn.Conv2d(4, 8, (3, 3)),
)
self.states_head = nn.Sequential(
nn.ConvTranspose2d(8, 16, (3, 3)),
nn.ELU(),
nn.ConvTranspose2d(16, action_space_dim, (5, 5)),
)
self.rewards_head = nn.Sequential(
nn.Flatten(),
nn.Linear(8*(self.h-4-2)*(self.w-4-2), 8),
nn.ELU(),
nn.Linear(8, action_space_dim),
)
self.dones_head = nn.Sequential(
nn.Flatten(),
nn.Linear(8*(self.h-4-2)*(self.w-4-2), 8),
nn.ELU(),
nn.Linear(8, action_space_dim),
nn.Sigmoid()
)
@staticmethod
def weight_init(m):
if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):
torch.nn.init.normal_(m.weight, mean=0.0, std=.001)
torch.nn.init.normal_(m.bias, mean=0.0, std=.001)
def forward(self, state, action):
T, R, D = self.states_head(self.features(state)), self.rewards_head(self.features(state)), self.dones_head(self.features(state))
return T[np.arange(len(action)), action.float().argmax(1), ...][:,None,:,:], torch.masked_select(R, action), torch.masked_select(D, action)
def predict(self, state):
return self.states_head(self.features(state)), self.rewards_head(self.features(state)), self.dones_head(self.features(state)) | 2,714 | 32.9375 | 147 | py |
SOPE | SOPE-master/ope/algos/fqe.py | import sys
import numpy as np
import pandas as pd
from copy import deepcopy
from keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
import keras
from keras.models import Sequential
from keras.layers import Dense, Conv2D, Flatten, MaxPool2D, concatenate, UpSampling2D, Reshape, Lambda
from keras.optimizers import Adam
from keras import backend as K
import tensorflow as tf
from tqdm import tqdm
from ope.utls.thread_safe import threadsafe_generator
from keras import regularizers
from sklearn.linear_model import LinearRegression, LogisticRegression
from collections import Counter
class DataHolder(object):
def __init__(self, s, a, r, s_, d, policy_action, original_shape):
self.states = s
self.next_states = s_
self.actions = a
self.rewards = r
self.dones = d
self.policy_action = policy_action
self.original_shape = original_shape
class FittedQEvaluation(object):
def __init__(self, data, gamma, frameskip=2, frameheight=2, modeltype = 'conv', processor=None):
self.data = data
self.gamma = gamma
self.frameskip = frameskip
self.frameheight = frameheight
self.modeltype = modeltype
self.processor = processor
# self.setup(deepcopy(self.trajectories))
def setup(self, dataset):
'''
'''
transitions = np.vstack([ np.array([x['x'] for x in dataset]).reshape(-1,1).T ,
np.array([x['a'] for x in dataset]).reshape(-1,1).T ,
np.array([x['x_prime'] for x in dataset]).reshape(-1,1).T
]).T
unique, idx, count = np.unique(transitions, return_index=True, return_counts=True, axis=0)
partial_transitions = np.vstack([ np.array([x['x'] for x in dataset]).reshape(-1,1).T ,
np.array([x['a'] for x in dataset]).reshape(-1,1).T ,
]).T
unique_a_given_x, idx_a_given_x, count_a_given_x = np.unique(partial_transitions, return_index=True, return_counts=True, axis=0)
# key=(state, action). value= number of times a was taking in state
all_counts_a_given_x = {tuple(key):value for key,value in zip(unique_a_given_x,count_a_given_x)}
prob = {}
for idx,row in enumerate(unique):
if tuple(row[:-1]) in prob:
prob[tuple(row[:-1])][row[-1]] = count[idx] / all_counts_a_given_x[(row[0],row[1])]
else:
prob[tuple(row[:-1])] = {}
prob[tuple(row[:-1])][row[-1]] = count[idx] / all_counts_a_given_x[(row[0],row[1])]
all_transitions = np.vstack([ np.array([x['x'] for x in dataset]).reshape(-1,1).T ,
np.array([x['a'] for x in dataset]).reshape(-1,1).T ,
np.array([x['x_prime'] for x in dataset]).reshape(-1,1).T ,
np.array([x['done'] for x in dataset]).reshape(-1,1).T ,
]).T
self.terminal_transitions = {tuple([x,a,x_prime]):1 for x,a,x_prime in all_transitions[all_transitions[:,-1] == True][:,:-1]}
self.P = prob
transitions = np.vstack([ np.array([x['x'] for x in dataset]).reshape(-1,1).T ,
np.array([x['a'] for x in dataset]).reshape(-1,1).T ,
# np.array([x['x_prime'] for x in dataset]).reshape(-1,1).T,
np.array([x['r'] for x in dataset]).reshape(-1,1).T ,
]).T
unique, idxs, counts = np.unique(transitions, return_index=True, return_counts=True, axis=0)
partial_transitions = np.vstack([ np.array([x['x'] for x in dataset]).reshape(-1,1).T ,
np.array([x['a'] for x in dataset]).reshape(-1,1).T ,
# np.array([x['x_prime'] for x in dataset]).reshape(-1,1).T,
]).T
unique_a_given_x, idx_a_given_x, count_a_given_x = np.unique(partial_transitions, return_index=True, return_counts=True, axis=0)
# key=(state, action). value= number of times a was taking in state
all_counts_a_given_x = {tuple(key):value for key,value in zip(unique_a_given_x,count_a_given_x)}
rew = {}
for idx,row in enumerate(unique):
if tuple(row[:-1]) in rew:
rew[tuple(row[:-1])][row[-1]] = counts[idx] / all_counts_a_given_x[tuple(row[:-1])]
else:
rew[tuple(row[:-1])] = {}
rew[tuple(row[:-1])][row[-1]] = counts[idx] / all_counts_a_given_x[tuple(row[:-1])]
self.R = rew
transitions = np.vstack([ np.array([x['x'] for x in dataset]).reshape(-1,1).T ,
np.array([x['a'] for x in dataset]).reshape(-1,1).T ,
np.array([x['x_prime'] for x in dataset]).reshape(-1,1).T,
np.array([range(len(x['x'])) for x in dataset]).reshape(-1,1).T,
np.array([x['r'] for x in dataset]).reshape(-1,1).T ,
]).T
unique, idxs, counts = np.unique(transitions, return_index=True, return_counts=True, axis=0)
partial_transitions = np.vstack([ np.array([x['x'] for x in dataset]).reshape(-1,1).T ,
np.array([x['a'] for x in dataset]).reshape(-1,1).T ,
np.array([x['x_prime'] for x in dataset]).reshape(-1,1).T,
np.array([range(len(x['x'])) for x in dataset]).reshape(-1,1).T,
]).T
unique_a_given_x, idx_a_given_x, count_a_given_x = np.unique(partial_transitions, return_index=True, return_counts=True, axis=0)
# key=(state, action). value= number of times a was taking in state
all_counts_a_given_x = {tuple(key):value for key,value in zip(unique_a_given_x,count_a_given_x)}
rew = {}
for idx,row in enumerate(unique):
if tuple(row[:-2]) in rew:
if row[-2] in rew[tuple(row[:-2])]:
rew[tuple(row[:-2])][row[-2]][row[-1]] = counts[idx] / all_counts_a_given_x[tuple(row[:-1])]
else:
rew[tuple(row[:-2])][row[-2]] = {}
rew[tuple(row[:-2])][row[-2]][row[-1]] = counts[idx] / all_counts_a_given_x[tuple(row[:-1])]
else:
rew[tuple(row[:-2])] = {}
rew[tuple(row[:-2])][row[-2]] = {}
rew[tuple(row[:-2])][row[-2]][row[-1]] = counts[idx] / all_counts_a_given_x[tuple(row[:-1])]
self.R1 = rew
def run(self, pi_b, pi_e, epsilon=0.001, max_epochs=10000, verbose = True):
data = self.data.basic_transitions()
action_space_dim = pi_b.action_space_dim
state_space_dim = len(np.unique(data[:,[0,3]].reshape(-1)))
# L = max(data[:,-1]) + 1
mapping = {state:idx for idx,state in enumerate(np.unique(data[:,[0,3]].reshape(-1)))}
U1 = np.zeros(shape=(state_space_dim,action_space_dim))
# print('Num unique in FQE: ', data.shape[0])
df = pd.DataFrame(data, columns=['x','a','t','x_prime','r','done'])
initial_states = Counter(df[df['t']==0]['x'])
total = sum(initial_states.values())
initial_states = {key:val/total for key,val in initial_states.items()}
count = -1
while True:
U = U1.copy()
delta = 0
count += 1
for (x,a), group in df.groupby(['x','a']):
x,a = int(x), int(a)
x = mapping[x]
# expected_reward = np.mean(group['r'])
# expected_Q = np.mean([[pi_e.predict([x_prime])[act]*U[x_prime,act] for x_prime in group['x_prime']] for act in range(action_space_dim)])
vals = np.zeros(group['x_prime'].shape)
x_primes = np.array([mapping[key] for key in group['x_prime']])
vals = np.array(group['r']) + self.gamma * np.sum(pi_e.predict(x_primes)*U[x_primes, :], axis=1)*(1-np.array(group['done']))
# for act in range(action_space_dim):
# try:
# vals += self.gamma*pi_e.predict(np.array(group['x_prime']))[range(len(x_primes)), act ]*U[x_primes,act]*(1-group['done'])
# except:
# import pdb; pdb.set_trace()
# vals += group['r']
U1[x, a] = np.mean(vals)#expected_reward + self.gamma*expected_Q
delta = max(delta, abs(U1[x,a] - U[x,a]))
if verbose: print(count, delta)
if self.gamma == 1:
# TODO: include initial state distribution
if delta < epsilon:
out = np.sum([prob*U1[0, new_a] for new_a,prob in enumerate(pi_e.predict([0])[0])]) #U[0,pi_e([0])][0]
return None, U1, mapping
# return out, U1, mapping
else:
if delta < epsilon * (1 - self.gamma) / self.gamma or count>max_epochs:
return None, U1, mapping #U[0,pi_e([0])][0]
# return np.sum([prob*U1[mapping[0], new_a] for new_a,prob in enumerate(pi_e.predict([0])[0])]), U1, mapping #U[0,pi_e([0])][0]
@staticmethod
def build_model(input_size, scope, action_space_dim=3, modeltype='conv'):
inp = keras.layers.Input(input_size, name='frames')
actions = keras.layers.Input((action_space_dim,), name='mask')
# conv1 = Conv2D(64, kernel_size=16, strides=2, activation='relu', data_format='channels_first')(inp)
# #pool1 = MaxPool2D(data_format='channels_first')(conv1)
# conv2 = Conv2D(64, kernel_size=8, strides=2, activation='relu', data_format='channels_first')(conv1)
# #pool2 = MaxPool2D(data_format='channels_first')(conv2)
# conv3 = Conv2D(64, kernel_size=4, strides=2, activation='relu', data_format='channels_first')(conv2)
# #pool3 = MaxPool2D(data_format='channels_first')(conv3)
# flat = Flatten()(conv3)
# dense1 = Dense(10, activation='relu')(flat)
# dense2 = Dense(30, activation='relu')(dense1)
# out = Dense(action_space_dim, activation='linear', name=scope+ 'all_Q')(dense2)
# filtered_output = keras.layers.dot([out, actions], axes=1)
# model = keras.models.Model(input=[inp, actions], output=[filtered_output])
# all_Q = keras.models.Model(inputs=[inp],
# outputs=model.get_layer(scope + 'all_Q').output)
# rmsprop = keras.optimizers.RMSprop(lr=0.0005, rho=0.9, epsilon=1e-5, decay=0.0)
# model.compile(loss='mse', optimizer=rmsprop)
def init(): return keras.initializers.TruncatedNormal(mean=0.0, stddev=0.1, seed=np.random.randint(2**32))
if modeltype == 'conv':
conv1 = Conv2D(8, (7,7), strides=(3,3), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(inp)
pool1 = MaxPool2D(data_format='channels_first')(conv1)
conv2 = Conv2D(16, (3,3), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(pool1)
pool2 = MaxPool2D(data_format='channels_first')(conv2)
flat1 = Flatten(name='flattened')(pool2)
out = Dense(256, activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(flat1)
elif modeltype == 'conv1':
def init(): return keras.initializers.TruncatedNormal(mean=0.0, stddev=0.001, seed=np.random.randint(2**32))
conv1 = Conv2D(16, (2,2), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(inp)
# pool1 = MaxPool2D(data_format='channels_first')(conv1)
# conv2 = Conv2D(16, (2,2), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(pool1)
# pool2 = MaxPool2D(data_format='channels_first')(conv2)
flat1 = Flatten(name='flattened')(conv1)
out = Dense(8, activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(flat1)
out = Dense(8, activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(out)
else:
def init(): return keras.initializers.TruncatedNormal(mean=0.0, stddev=.1, seed=np.random.randint(2**32))
flat = Flatten()(inp)
dense1 = Dense(64, activation='elu',kernel_initializer=init(), bias_initializer=init())(flat)
# dense2 = Dense(256, activation='relu',kernel_initializer=init(), bias_initializer=init())(dense1)
dense3 = Dense(32, activation='elu',kernel_initializer=init(), bias_initializer=init())(dense1)
out = Dense(8, activation='elu', name='out',kernel_initializer=init(), bias_initializer=init())(dense3)
all_actions = Dense(action_space_dim, name=scope + 'all_Q', activation="linear",kernel_initializer=init(), bias_initializer=init())(out)
output = keras.layers.dot([all_actions, actions], 1)
model = keras.models.Model(inputs=[inp, actions], outputs=output)
all_Q = keras.models.Model(inputs=[inp],
outputs=model.get_layer(scope + 'all_Q').output)
rmsprop = keras.optimizers.RMSprop(lr=0.05, rho=0.95, epsilon=1e-08, decay=1e-3)#, clipnorm=1.)
adam = keras.optimizers.Adam(clipnorm=1.)
model.compile(loss='mse', optimizer=adam, metrics=['accuracy'])
return model, all_Q
@staticmethod
def copy_over_to(source, target):
target.set_weights(source.get_weights())
@staticmethod
def weight_change_norm(model, target_model):
norm_list = []
number_of_layers = len(model.layers)
for i in range(number_of_layers):
model_matrix = model.layers[i].get_weights()
target_model_matrix = target_model.layers[i].get_weights()
if len(model_matrix) >0:
#print "layer ", i, " has shape ", model_matrix[0].shape
if model_matrix[0].shape[0] > 0:
norm_change = np.linalg.norm(model_matrix[0]-target_model_matrix[0])
norm_list.append(norm_change)
return sum(norm_list)*1.0/len(norm_list)
def run_linear(self, env, pi_b, pi_e, max_epochs, epsilon=.001, fit_intercept=True):
initial_states = self.data.initial_states()
self.Q_k = LinearRegression(fit_intercept=fit_intercept)
values = []
states = self.data.states()
states = states.reshape(-1,np.prod(states.shape[2:]))
actions = self.data.actions().reshape(-1)
actions = np.eye(env.n_actions)[actions]
X = np.hstack([states, actions])
next_states = self.data.next_states()
next_states = next_states.reshape(-1,np.prod(next_states.shape[2:]))
policy_action = self.data.target_propensity()
lengths = self.data.lengths()
omega = self.data.omega()
rewards = self.data.rewards()
not_dones = 1-self.data.dones()
for epoch in tqdm(range(max_epochs)):
if epoch:
inp = np.repeat(next_states, env.n_actions, axis=0)
act = np.tile(np.arange(env.n_actions), len(next_states))
inp = np.hstack([inp.reshape(inp.shape[0],-1), np.eye(env.n_actions)[act]])
Q_val = self.Q_k.predict(inp).reshape(policy_action.shape)
else:
Q_val = np.zeros_like(policy_action)
Q = rewards + self.gamma * (Q_val * policy_action).sum(axis=-1) * not_dones
Q = Q.reshape(-1)
self.Q_k.fit(X, Q)
# Check if converged
actions = pi_e.sample(initial_states)
Q_val = self.Q_k.predict(np.hstack([initial_states.reshape(initial_states.shape[0],-1), np.eye(env.n_actions)[actions]]))
values.append(np.mean(Q_val))
M = 20
# print(values[-1], np.mean(values[-M:]), np.abs(np.mean(values[-M:])- np.mean(values[-(M+1):-1])), 1e-4*np.abs(np.mean(values[-(M+1):-1])))
if epoch>M and np.abs(np.mean(values[-M:]) - np.mean(values[-(M+1):-1])) < 1e-4*np.abs(np.mean(values[-(M+1):-1])):
break
#np.mean(values[-10:]), self.Q_k,
return self.Q_k
def run_linear_value_iter(self, env, pi_b, pi_e, max_epochs, epsilon=.001):
initial_states = self.data.initial_states()
self.Q_k = LinearRegression()
values = []
states = self.data.states()
states = states.reshape(-1,np.prod(states.shape[2:]))
actions = self.data.actions().reshape(-1)
actions = np.eye(env.n_actions)[actions]
X = states #np.hstack([states, actions])
next_states = self.data.next_states()
next_states = next_states.reshape(-1,np.prod(next_states.shape[2:]))
policy_action = self.data.target_propensity()
lengths = self.data.lengths()
omega = self.data.omega()
rewards = self.data.rewards()
not_dones = 1-self.data.dones()
for epoch in tqdm(range(max_epochs)):
if epoch:
# inp = np.repeat(next_states, env.n_actions, axis=0)
inp = next_states
# act = np.tile(np.arange(env.n_actions), len(next_states))
inp = inp.reshape(inp.shape[0],-1) #np.hstack([inp.reshape(inp.shape[0],-1), np.eye(env.n_actions)[act]])
Q_val = self.Q_k.predict(inp).reshape(policy_action[...,0].shape)
else:
Q_val = np.zeros_like(policy_action[...,0]) + 1
Q = rewards + self.gamma * Q_val * not_dones
Q = Q.reshape(-1)
self.Q_k.fit(X, Q)
# Check if converged
actions = pi_e.sample(initial_states)
# Q_val = self.Q_k.predict(np.hstack([initial_states.reshape(initial_states.shape[0],-1), np.eye(env.n_actions)[actions]]))
Q_val = self.Q_k.predict(initial_states.reshape(initial_states.shape[0],-1)) #self.Q_k.predict(np.hstack([, np.eye(env.n_actions)[actions]]))
values.append(np.mean(Q_val))
M = 20
# print(values[-1], np.mean(values[-M:]), np.abs(np.mean(values[-M:])- np.mean(values[-(M+1):-1])), 1e-4*np.abs(np.mean(values[-(M+1):-1])))
print(self.Q_k.coef_)
if epoch>M and np.abs(np.mean(values[-M:]) - np.mean(values[-(M+1):-1])) < 1e-4*np.abs(np.mean(values[-(M+1):-1])):
break
#np.mean(values[-10:]), self.Q_k,
return self.Q_k
def run_NN(self, env, pi_b, pi_e, max_epochs, epsilon=0.001, perc_of_dataset = 1.):
initial_states = self.data.initial_states()
if self.processor: initial_states = self.processor(initial_states)
self.dim_of_actions = env.n_actions
self.Q_k = None
self.Q_k_minus_1 = None
# earlyStopping = EarlyStopping(monitor='val_loss', min_delta=1e-4, patience=10, verbose=1, mode='min', restore_best_weights=True)
# mcp_save = ModelCheckpoint('fqe.hdf5', save_best_only=True, monitor='val_loss', mode='min')
# reduce_lr_loss = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=7, verbose=1, min_delta=1e-4, mode='min')
self.more_callbacks = [] #[earlyStopping, mcp_save, reduce_lr_loss]
# if self.modeltype == 'conv':
# im = env.pos_to_image(np.array(self.trajectories[0]['x'][0])[np.newaxis,...])
# else:
# im = np.array(self.trajectories[0]['frames'])[np.array(self.trajectories[0]['x'][0]).astype(int)][np.newaxis,...]
im = self.data.states()[0]
if self.processor: im = self.processor(im)
self.Q_k, self.Q_k_all = self.build_model(im.shape[1:], 'Q_k', modeltype=self.modeltype, action_space_dim=env.n_actions)
self.Q_k_minus_1, self.Q_k_minus_1_all = self.build_model(im.shape[1:], 'Q_k_minus_1', modeltype=self.modeltype, action_space_dim=env.n_actions)
# print('testing Q_k:', )
tmp_act = np.eye(env.n_actions)[[0]]
self.Q_k.predict([[im[0]], tmp_act])
# print('testing Q_k all:', )
self.Q_k_all.predict([[im[0]]])
# print('testing Q_k_minus_1:', )
self.Q_k_minus_1.predict([[im[0]], tmp_act])
# print('testing Q_k_minus_1 all:', )
self.Q_k_minus_1_all.predict([[im[0]]])
self.copy_over_to(self.Q_k, self.Q_k_minus_1)
values = []
# policy_action = np.vstack([episode['target_propensity'] for episode in self.trajectories])
# if self.modeltype == 'conv':
# initial_states = env.pos_to_image(env.initial_states())
# else:
# #only works for mountain car
# initial_states = np.array([np.tile([x[0],0],self.frameheight).reshape(-1,self.frameheight) for x in env.initial_states()])
# transitions = np.hstack([ np.vstack([x['x'] for x in self.trajectories]),
# np.hstack([x['a'] for x in self.trajectories]).T.reshape(-1, 1),
# np.hstack([x['r'] for x in self.trajectories]).T.reshape(-1, 1),
# np.vstack([x['x_prime'] for x in self.trajectories]),
# np.hstack([x['done'] for x in self.trajectories]).T.reshape(-1, 1),
# policy_action,
# np.hstack([[n]*len(x['x']) for n,x in enumerate(self.trajectories)]).T.reshape(-1,1),])
# frames = np.array([x['frames'] for x in self.trajectories])
# #import pdb; pdb.set_trace()
print('Training: FQE')
losses = []
self.processed_data = self.fill(env)
self.Q_k_minus_1_all.epoch = 0
for k in tqdm(range(max_epochs)):
batch_size = 32
dataset_length = self.data.num_tuples()
perm = np.random.permutation(range(dataset_length))
eighty_percent_of_set = int(1.*len(perm))
training_idxs = perm[:eighty_percent_of_set]
validation_idxs = perm[eighty_percent_of_set:]
training_steps_per_epoch = int(perc_of_dataset * np.ceil(len(training_idxs)/float(batch_size)))
validation_steps_per_epoch = int(np.ceil(len(validation_idxs)/float(batch_size)))
# steps_per_epoch = 1 #int(np.ceil(len(dataset)/float(batch_size)))
train_gen = self.generator(env, pi_e, training_idxs, fixed_permutation=True, batch_size=batch_size)
# val_gen = self.generator(policy, dataset, validation_idxs, fixed_permutation=True, batch_size=batch_size)
# import pdb; pdb.set_trace()
# train_gen = self.generator(env, pi_e, (transitions,frames), training_idxs, fixed_permutation=True, batch_size=batch_size)
# inp, out = next(train_gen)
M = 5
hist = self.Q_k.fit_generator(train_gen,
steps_per_epoch=training_steps_per_epoch,
#validation_data=val_gen,
#validation_steps=validation_steps_per_epoch,
epochs=1,
max_queue_size=50,
workers=2,
use_multiprocessing=False,
verbose=1,
callbacks = self.more_callbacks)
norm_change = self.weight_change_norm(self.Q_k, self.Q_k_minus_1)
self.copy_over_to(self.Q_k, self.Q_k_minus_1)
losses.append(hist.history['loss'])
actions = pi_e.sample(initial_states)
assert len(actions) == initial_states.shape[0]
Q_val = self.Q_k_all.predict(initial_states)[np.arange(len(actions)), actions]
values.append(np.mean(Q_val))
print(values[-1], norm_change, np.mean(values[-M:]), np.abs(np.mean(values[-M:])- np.mean(values[-(M+1):-1])), 1e-4*np.abs(np.mean(values[-(M+1):-1])))
if k>M and np.abs(np.mean(values[-M:]) - np.mean(values[-(M+1):-1])) < 1e-4*np.abs(np.mean(values[-(M+1):-1])):
break
return np.mean(values[-10:]), self.Q_k, self.Q_k_all
# actions = policy(initial_states[:,np.newaxis,...], x_preprocessed=True)
# Q_val = self.Q_k.all_actions([initial_states], x_preprocessed=True)[np.arange(len(actions)), actions]
# return np.mean(Q_val)*dataset.scale, values
def fill(self, env):
states = self.data.states()
states = states.reshape(-1,np.prod(states.shape[2:]))
actions = self.data.actions().reshape(-1)
actions = np.eye(env.n_actions)[actions]
next_states = self.data.next_states()
original_shape = next_states.shape
next_states = next_states.reshape(-1,np.prod(next_states.shape[2:]))
policy_action = self.data.next_target_propensity().reshape(-1, env.n_actions)
rewards = self.data.rewards().reshape(-1)
dones = self.data.dones()
dones = dones.reshape(-1)
return DataHolder(states, actions, rewards, next_states, dones, policy_action, original_shape)
@threadsafe_generator
def generator(self, env, pi_e, all_idxs, fixed_permutation=False, batch_size = 64):
# dataset, frames = dataset
data_length = len(all_idxs)
steps = int(np.ceil(data_length/float(batch_size)))
# states = self.data.states()
# states = states.reshape(-1,np.prod(states.shape[2:]))
# actions = self.data.actions().reshape(-1)
# actions = np.eye(env.n_actions)[actions]
# next_states = self.data.next_states()
# original_shape = next_states.shape
# next_states = next_states.reshape(-1,np.prod(next_states.shape[2:]))
# policy_action = self.data.target_propensity().reshape(-1, env.n_actions)
# rewards = self.data.rewards().reshape(-1)
# dones = self.data.dones()
# dones = dones.reshape(-1)
states = self.processed_data.states
actions = self.processed_data.actions
next_states = self.processed_data.next_states
original_shape = self.processed_data.original_shape
policy_action = self.processed_data.policy_action
rewards = self.processed_data.rewards
dones = self.processed_data.dones
alpha = 1.
# Rebalance dataset
# probs = np.hstack([np.zeros((dones.shape[0],2)), dones,])[:,:-2]
# if np.sum(probs):
# done_probs = probs / np.sum(probs)
# probs = 1 - probs + done_probs
# else:
# probs = 1 - probs
# probs = probs.reshape(-1)
# probs /= np.sum(probs)
# probs = probs[all_idxs]
# probs /= np.sum(probs)
# while True:
# batch_idxs = np.random.choice(all_idxs, batch_size, p = probs)
while True:
perm = np.random.permutation(all_idxs)
for batch in np.arange(steps):
batch_idxs = perm[(batch*batch_size):((batch+1)*batch_size)]
x = states[batch_idxs].reshape(tuple([-1]) + original_shape[2:])
if self.processor: x = self.processor(x)
acts = actions[batch_idxs]
x_ = next_states[batch_idxs].reshape(tuple([-1]) + original_shape[2:])
if self.processor: x_ = self.processor(x_)
pi_a_given_x = policy_action[batch_idxs]
not_dones = 1-dones[batch_idxs]
rew = rewards[batch_idxs]
Q_val = self.Q_k_minus_1_all.predict(x_).reshape(pi_a_given_x.shape)
# if self.Q_k_minus_1_all.epoch == 0:
# Q_val = np.zeros_like(Q_val)
# Q_val = Q_val[np.arange(len(acts)), np.argmax(acts,axis=1)]
Q_val = (Q_val * pi_a_given_x).sum(axis=-1)
new_Q = rew + self.gamma * (Q_val * not_dones).reshape(-1)
old_Q = 0 #(self.Q_k.predict([x, acts]).reshape(-1) * not_dones)
Q = (old_Q) + (alpha)*(new_Q-old_Q) # Q-learning style update w/ learning rate, to stabilize
yield ([x, acts], Q)
| 28,849 | 48.655766 | 218 | py |
SOPE | SOPE-master/ope/algos/dm_regression.py |
import sys
import numpy as np
import pandas as pd
sys.path.append("..")
from copy import deepcopy
from keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
import keras
from keras.models import Sequential
from keras.layers import Dense, Conv2D, Flatten, MaxPool2D, concatenate, UpSampling2D, Reshape, Lambda
from keras.optimizers import Adam
from keras import backend as K
import tensorflow as tf
from tqdm import tqdm
from ope.utls.thread_safe import threadsafe_generator
from keras import regularizers
from sklearn.linear_model import LinearRegression, LogisticRegression
from functools import partial
class DirectMethodRegression(object):
def __init__(self, data, gamma, frameskip=2, frameheight=2, modeltype = 'conv', processor=None):
self.data = data
self.gamma = gamma
self.frameskip = frameskip
self.frameheight = frameheight
self.modeltype = modeltype
self.processor = processor
# self.setup(deepcopy(self.trajectories))
def wls_sherman_morrison(self, phi_in, rewards_in, omega_in, lamb, omega_regularizer, cond_number_threshold_A, block_size=None):
# omega_in_2 = block_diag(*omega_in)
# omega_in_2 += omega_regularizer * np.eye(len(omega_in_2))
# Aw = phi_in.T.dot(omega_in_2).dot(phi_in)
# Aw = Aw + lamb * np.eye(phi_in.shape[1])
# print(np.linalg.cond(Aw))
# bw = phi_in.T.dot(omega_in_2).dot(rewards_in)
feat_dim = phi_in.shape[1]
b = np.zeros((feat_dim, 1))
B = np.eye(feat_dim)
data_count = len(omega_in)
if np.isscalar(omega_in[0]):
omega_size = 1
I_a = 1
else:
omega_size = omega_in[0].shape[0]
I_a = np.eye(omega_size)
for i in range(data_count):
if omega_in[i] is None:
# if omega_in[i] is None or (omega_size==1 and omega_in[i] == 0):
#omega_in[i] = I_a
#rewards_in[i] = 1
continue
omeg_i = omega_in[i] + omega_regularizer * I_a
#if omega_size > 1:
# omeg_i = omeg_i / np.max(omeg_i)
feat = phi_in[i * omega_size: (i + 1) * omega_size, :]
# A = A + feat.T.dot(omega_list[i]).dot(feat)
rews_i = np.reshape(rewards_in[i * omega_size: (i + 1) * omega_size], [omega_size, 1])
b = b + feat.T.dot(omeg_i).dot(rews_i)
# Sherman–Morrison–Woodbury formula:
# (B + UCV)^-1 = B^-1 - B^-1 U ( C^-1 + V B^-1 U)^-1 V B^-1
# in our case: U = feat.T C = omega_list[i] V = feat
# print(omeg_i)
if omega_size > 1:
C_inv = np.linalg.inv(omeg_i)
else:
C_inv = 1/omeg_i
if np.linalg.norm(feat.dot(B).dot(feat.T)) < 0.0000001:
inner_inv = omeg_i
else:
inner_inv = np.linalg.inv(C_inv + feat.dot(B).dot(feat.T))
B = B - B.dot(feat.T).dot(inner_inv).dot(feat).dot(B)
weight_prim = B.dot(b)
weight = weight_prim.reshape((-1,))
return weight
def run(self, pi_b, pi_e, epsilon=0.001):
dataset = self.data.all_transitions()
frames = self.data.frames()
omega = self.data.omega()
rewards = self.data.rewards()
omega = [np.cumprod(om) for om in omega]
gamma_vec = self.gamma**np.arange(max([len(x) for x in omega]))
factors, Rs = [], []
for data in dataset:
ts = data[-1]
traj_num = data[-2]
i,t = int(traj_num), int(ts)
Rs.append( np.sum( omega[i][t:]/omega[i][t] * gamma_vec[t:]/gamma_vec[t] * rewards[i][t:] ) )
factors.append( gamma_vec[t] * omega[i][t] )
self.alpha = 1
self.lamb = 1
self.cond_number_threshold_A = 1
block_size = len(dataset)
phi = self.compute_grid_features()
self.weight = self.wls_sherman_morrison(phi, Rs, factors, self.lamb, self.alpha, self.cond_number_threshold_A, block_size)
return DMModel(self.weight,
self.data)
def compute_feature_without_time(self, state, action, step):
T = max(self.data.lengths())
n_dim = self.data.n_dim
n_actions = self.data.n_actions
# feature_dim = n_dim + n_actions
# feature_dim =
phi = np.zeros((n_dim, n_actions))
# for k in range(step, T):
# phi[state * n_actions + action] = env.gamma_vec[k - step]
# phi = np.hstack([np.eye(n_dim)[int(state)] , np.eye(n_actions)[action] ])
# phi[action*n_dim: (action+1)*n_dim] = state + 1
# phi[int(state*n_actions + action)] = 1
phi[int(state), int(action)] = 1
phi = phi.reshape(-1)
return phi
def compute_feature(self, state, action, step):
return self.compute_feature_without_time(state, action, step)
def compute_grid_features(self):
T = max(self.data.lengths())
n_dim = self.data.n_dim
n_actions = self.data.n_actions
n = len(self.data)
data_dim = n * T
phi = data_dim * [None]
lengths = self.data.lengths()
for i in range(n):
states = self.data.states(False, i, i+1)
actions = self.data.actions()[i]
for t in range(max(lengths)):
if t < lengths[i]:
s = states[t]
action = int(actions[t])
phi[i * T + t] = self.compute_feature(s, action, t)
else:
phi[i * T + t] = np.zeros(len(phi[0]))
return np.array(phi, dtype='float')
@staticmethod
def build_model(input_size, scope, action_space_dim=3, modeltype='conv'):
inp = keras.layers.Input(input_size, name='frames')
actions = keras.layers.Input((action_space_dim,), name='mask')
factors = keras.layers.Input((1,), name='weights')
# conv1 = Conv2D(64, kernel_size=16, strides=2, activation='relu', data_format='channels_first')(inp)
# #pool1 = MaxPool2D(data_format='channels_first')(conv1)
# conv2 = Conv2D(64, kernel_size=8, strides=2, activation='relu', data_format='channels_first')(conv1)
# #pool2 = MaxPool2D(data_format='channels_first')(conv2)
# conv3 = Conv2D(64, kernel_size=4, strides=2, activation='relu', data_format='channels_first')(conv2)
# #pool3 = MaxPool2D(data_format='channels_first')(conv3)
# flat = Flatten()(conv3)
# dense1 = Dense(10, activation='relu')(flat)
# dense2 = Dense(30, activation='relu')(dense1)
# out = Dense(action_space_dim, activation='linear', name=scope+ 'all_Q')(dense2)
# filtered_output = keras.layers.dot([out, actions], axes=1)
# model = keras.models.Model(input=[inp, actions], output=[filtered_output])
# all_Q = keras.models.Model(inputs=[inp],
# outputs=model.get_layer(scope + 'all_Q').output)
# rmsprop = keras.optimizers.RMSprop(lr=0.0005, rho=0.9, epsilon=1e-5, decay=0.0)
# model.compile(loss='mse', optimizer=rmsprop)
def init(): return keras.initializers.TruncatedNormal(mean=0.0, stddev=0.1, seed=np.random.randint(2**32))
if modeltype == 'conv':
conv1 = Conv2D(8, (7,7), strides=(3,3), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(inp)
pool1 = MaxPool2D(data_format='channels_first')(conv1)
conv2 = Conv2D(16, (3,3), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(pool1)
pool2 = MaxPool2D(data_format='channels_first')(conv2)
flat1 = Flatten(name='flattened')(pool2)
out = Dense(256, activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(flat1)
elif modeltype == 'conv1':
def init(): return keras.initializers.TruncatedNormal(mean=0.0, stddev=0.001, seed=np.random.randint(2**32))
conv1 = Conv2D(16, (2,2), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(inp)
# pool1 = MaxPool2D(data_format='channels_first')(conv1)
# conv2 = Conv2D(16, (2,2), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(pool1)
# pool2 = MaxPool2D(data_format='channels_first')(conv2)
flat1 = Flatten(name='flattened')(conv1)
out = Dense(8, activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(flat1)
out = Dense(8, activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(out)
else:
def init(): return keras.initializers.TruncatedNormal(mean=0.0, stddev=.1, seed=np.random.randint(2**32))
# flat = Flatten()(inp)
# dense1 = Dense(256, activation='relu',kernel_initializer=init(), bias_initializer=init())(flat)
# dense2 = Dense(256, activation='relu',kernel_initializer=init(), bias_initializer=init())(dense1)
# dense3 = Dense(128, activation='relu',kernel_initializer=init(), bias_initializer=init())(dense2)
# out = Dense(32, activation='relu', name='out',kernel_initializer=init(), bias_initializer=init())(dense3)
flat = Flatten()(inp)
dense1 = Dense(16, activation='relu',kernel_initializer=init(), bias_initializer=init())(flat)
# dense2 = Dense(256, activation='relu',kernel_initializer=init(), bias_initializer=init())(dense1)
dense3 = Dense(8, activation='relu',kernel_initializer=init(), bias_initializer=init())(dense1)
out = Dense(4, activation='relu', name='out',kernel_initializer=init(), bias_initializer=init())(dense3)
all_actions = Dense(action_space_dim, name=scope + 'all_Q', activation="linear",kernel_initializer=init(), bias_initializer=init())(out)
output = keras.layers.dot([all_actions, actions], 1)
model = keras.models.Model(inputs=[inp, actions], outputs=output)
model1 = keras.models.Model(inputs=[inp, actions, factors], outputs=output)
all_Q = keras.models.Model(inputs=[inp],
outputs=model.get_layer(scope + 'all_Q').output)
# rmsprop = keras.optimizers.RMSprop(lr=0.005, rho=0.95, epsilon=1e-08, decay=1e-3)#, clipnorm=1.)
adam = keras.optimizers.Adam()
def DMloss(y_true, y_pred, weights):
return K.sum(weights * K.square(y_pred - y_true))
weighted_loss = partial(DMloss, weights=factors)
model1.compile(loss=weighted_loss, optimizer=adam, metrics=['accuracy'])
# print(model.summary())
return model1, model, all_Q
@staticmethod
def copy_over_to(source, target):
target.set_weights(source.get_weights())
@staticmethod
def weight_change_norm(model, target_model):
norm_list = []
number_of_layers = len(model.layers)
for i in range(number_of_layers):
model_matrix = model.layers[i].get_weights()
target_model_matrix = target_model.layers[i].get_weights()
if len(model_matrix) >0:
#print "layer ", i, " has shape ", model_matrix[0].shape
if model_matrix[0].shape[0] > 0:
norm_change = np.linalg.norm(model_matrix[0]-target_model_matrix[0])
norm_list.append(norm_change)
return sum(norm_list)*1.0/len(norm_list)
def run_linear(self, env, pi_b, pi_e, max_epochs, epsilon=.001):
self.Q_k = LinearRegression()
states = self.data.states()
states = states.reshape(-1,np.prod(states.shape[2:]))
lengths = self.data.lengths()
omega = self.data.omega()
rewards = self.data.rewards()
actions = self.data.actions().reshape(-1)
omega = [np.cumprod(om) for om in omega]
gamma_vec = self.gamma**np.arange(max([len(x) for x in omega]))
factors, Rs = [], []
for traj_num, ts in enumerate(self.data.ts()):
for t in ts:
i,t = int(traj_num), int(t)
if omega[i][t]:
Rs.append( np.sum( omega[i][t:]/omega[i][t] * gamma_vec[t:]/gamma_vec[t] * rewards[i][t:] ) )
else:
Rs.append( 0 )
factors.append( gamma_vec[t] * omega[i][t] )
Rs = np.array(Rs)
factors = np.array(factors)
actions = np.eye(self.data.n_actions)[actions]
return self.Q_k.fit(np.hstack([states, actions]), Rs, factors)
def run_NN(self, env, pi_b, pi_e, max_epochs, epsilon=0.001):
self.dim_of_actions = env.n_actions
self.Q_k = None
self.Q_k_minus_1 = None
earlyStopping = EarlyStopping(monitor='val_loss', min_delta=1e-4, patience=5, verbose=1, mode='min', restore_best_weights=True)
mcp_save = ModelCheckpoint('dm_regression.hdf5', save_best_only=True, monitor='val_loss', mode='min')
reduce_lr_loss = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=3, verbose=1, min_delta=1e-4, mode='min')
self.more_callbacks = [earlyStopping, reduce_lr_loss]
# if self.modeltype == 'conv':
# im = self.trajectories.states()[0,0,...] #env.pos_to_image(np.array(self.trajectories[0]['x'][0])[np.newaxis,...])
# else:
# im = np.array(self.trajectories[0]['frames'])[np.array(self.trajectories[0]['x'][0]).astype(int)][np.newaxis,...]
im = self.data.states()[0]
if self.processor: im = self.processor(im)
self.Q_k, self.Q, self.Q_k_all = self.build_model(im.shape[1:], 'Q_k', modeltype=self.modeltype, action_space_dim=env.n_actions)
print('Training: Model Free')
losses = []
for k in tqdm(range(1)):
batch_size = 32
dataset_length = self.data.num_tuples()
perm = np.random.permutation(range(dataset_length))
eighty_percent_of_set = int(.8*len(perm))
training_idxs = perm[:eighty_percent_of_set]
validation_idxs = perm[eighty_percent_of_set:]
training_steps_per_epoch = int(1.*np.ceil(len(training_idxs)/float(batch_size)))
validation_steps_per_epoch = int(np.ceil(len(validation_idxs)/float(batch_size)))
train_gen = self.generator(env, pi_e, training_idxs, fixed_permutation=True, batch_size=batch_size)
val_gen = self.generator(env, pi_e, validation_idxs, fixed_permutation=True, batch_size=batch_size, is_train=False)
hist = self.Q_k.fit_generator(train_gen,
steps_per_epoch=training_steps_per_epoch,
validation_data=val_gen,
validation_steps=validation_steps_per_epoch,
epochs=max_epochs,
max_queue_size=1,
workers=1,
use_multiprocessing=False,
verbose=1,
callbacks = self.more_callbacks)
return self.Q_k, self.Q_k_all
@threadsafe_generator
def generator(self, env, pi_e, all_idxs, fixed_permutation=False, batch_size = 64, is_train=True):
data_length = len(all_idxs)
steps = int(np.ceil(data_length/float(batch_size)))
states = self.data.states()
states = states.reshape(tuple([-1]) + states.shape[2:])
lengths = self.data.lengths()
omega = self.data.omega()
rewards = self.data.rewards()
actions = self.data.actions().reshape(-1)
omega = [np.cumprod(om) for om in omega]
gamma_vec = self.gamma**np.arange(max([len(x) for x in omega]))
factors, Rs = [], []
for traj_num, ts in enumerate(self.data.ts()):
for t in ts:
i,t = int(traj_num), int(t)
if omega[i][t]:
Rs.append( np.sum( omega[i][t:]/omega[i][t] * gamma_vec[t:]/gamma_vec[t] * rewards[i][t:] ) )
else:
Rs.append( 0 )
factors.append( gamma_vec[t] * omega[i][t] )
Rs = np.array(Rs)
factors = np.array(factors)
dones = self.data.dones()
alpha = 1.
# Rebalance dataset
probs = np.hstack([np.zeros((dones.shape[0],2)), dones,])[:,:-2]
if np.sum(probs):
done_probs = probs / np.sum(probs)
probs = 1 - probs + done_probs
else:
probs = 1 - probs
probs = probs.reshape(-1)
probs /= np.sum(probs)
probs = probs[all_idxs]
probs /= np.sum(probs)
dones = dones.reshape(-1)
# if is_train:
# while True:
# batch_idxs = np.random.choice(all_idxs, batch_size, p = probs)
# x = states[batch_idxs]
# weight = factors[batch_idxs]
# R = Rs[batch_idxs]
# acts = actions[batch_idxs]
# yield ([x, np.eye(3)[acts], np.array(weight).reshape(-1,1)], [np.array(R).reshape(-1,1)])
# else:
#
while True:
perm = np.random.permutation(all_idxs)
for batch in np.arange(steps):
batch_idxs = perm[(batch*batch_size):((batch+1)*batch_size)]
x = states[batch_idxs]
if self.processor: x = self.processor(x)
weight = factors[batch_idxs] #* probs[batch_idxs]
R = Rs[batch_idxs]
acts = actions[batch_idxs]
yield ([x, np.eye(env.n_actions)[acts], np.array(weight).reshape(-1,1)], [np.array(R).reshape(-1,1)])
class DMModel(object):
def __init__(self, weights, data):
self.weights = weights
self.data = data
def predict(self, x):
if (self.data.n_dim + self.data.n_actions) == x.shape[1]:
acts = np.argmax(x[:,-self.data.n_actions:], axis=1)
S = x[:,:self.data.n_dim]
Q = np.zeros(x.shape[0])
for i, (s, a) in enumerate(zip(S, acts)):
s = int(s)
a = int(a)
Q[i] = np.matmul(self.weights, self.compute_feature(s, a, 0))
return Q
elif (1 + self.data.n_actions) == x.shape[1]:
acts = np.argmax(x[:,-self.data.n_actions:], axis=1)
S = x[:,:1]
Q = np.zeros(x.shape[0])
for i, (s, a) in enumerate(zip(S, acts)):
Q[i] = np.matmul(self.weights, self.compute_feature(s, a, 0))
return Q
else:
raise
def compute_feature_without_time(self, state, action, step):
T = max(self.data.lengths())
n_dim = self.data.n_dim
n_actions = self.data.n_actions
# feature_dim = n_dim * n_actions
# phi = np.zeros(feature_dim)
# # for k in range(step, T):
# # phi[state * n_actions + action] = env.gamma_vec[k - step]
# # phi = np.hstack([np.eye(n_dim)[int(state)] , np.eye(n_actions)[action] ])
# # phi[action*n_dim: (action+1)*n_dim] = 1 #state + 1
# phi[int(state*n_actions + action)] = 1
phi = np.zeros((n_dim, n_actions))
# for k in range(step, T):
# phi[state * n_actions + action] = env.gamma_vec[k - step]
# phi = np.hstack([np.eye(n_dim)[int(state)] , np.eye(n_actions)[action] ])
# phi[action*n_dim: (action+1)*n_dim] = state + 1
# phi[int(state*n_actions + action)] = 1
phi[int(state), int(action)] = 1
phi = phi.reshape(-1)
return phi
def compute_feature(self, state, action, step):
return self.compute_feature_without_time(state, action, step)
| 20,324 | 40.64959 | 218 | py |
SOPE | SOPE-master/ope/algos/infinite_horizon.py | import numpy as np
import tensorflow as tf
from time import sleep
import sys
import os
from tqdm import tqdm
from tensorflow.python import debug as tf_debug
import json
from scipy.optimize import linprog
from scipy.optimize import minimize
import quadprog
import keras
from keras.layers import Dense, Conv2D, Flatten, MaxPool2D, concatenate, UpSampling2D, Reshape, Lambda, Conv2DTranspose
from keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
from keras.optimizers import Adam
from keras import backend as K
from tqdm import tqdm
from ope.utls.thread_safe import threadsafe_generator
from keras import regularizers
# Hyper parameter
#Learning_rate = 1e-3
#initial_stddev = 0.5
#Training Parameter
training_batch_size = 1024 #1024 * 2**2
training_maximum_iteration = 40001
TEST_NUM = 0
NUMBER_OF_REPEATS = 1
from ope.utils import keyboard
class InfiniteHorizonOPE(object):
def __init__(self, data, w_hidden, Learning_rate, reg_weight, gamma, discrete, modeltype, env=None, processor=None, weighted=True):
self.data = data
self.modeltype = modeltype
self.gamma = gamma
self.is_discrete = discrete
self.processor = processor
self.weighted = weighted
if self.is_discrete:
self.obs_dim = env.num_states() if env is not None else self.data.num_states()
self.den_discrete = Density_Ratio_discounted(self.obs_dim, gamma)
else:
# self.g = tf.Graph()
# with self.g.as_default():
# with tf.variable_scope('infhorizon', reuse=False):
# self._build_graph(w_hidden, Learning_rate, reg_weight)
# self._init_session()
pass
def build_model(self, input_size, scope, action_space_dim=3, modeltype='conv'):
isStart = keras.layers.Input(shape=(1,), name='dummy')
state = keras.layers.Input(shape=input_size, name='state')
next_state = keras.layers.Input(shape=input_size, name='next_state')
median_dist = keras.layers.Input(shape=(1,), name='med_dist')
policy_ratio = keras.layers.Input(shape=(1,), name='policy_ratio')
if modeltype == 'conv':
def init(): return keras.initializers.RandomNormal(mean=0.0, stddev=.003, seed=np.random.randint(2**32))
conv1 = Conv2D(8, (7,7), strides=(3,3), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init())
pool1 = MaxPool2D(data_format='channels_first')
conv2 = Conv2D(16, (3,3), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init())
pool2 = MaxPool2D(data_format='channels_first')
flat1 = Flatten(name='flattened')
out = Dense(1, activation='linear',kernel_initializer=init(), bias_initializer=init())
output = Lambda(lambda x: tf.exp(tf.clip_by_value(x,-10,10)))
w = output(out(flat1(pool2(conv2(pool1(conv1(state)))))))
w_next = output(out(flat1(pool2(conv2(pool1(conv1(next_state)))))))
trainable_model = keras.models.Model(inputs=[state,next_state,policy_ratio,isStart,median_dist], outputs=[w])
w_model = keras.models.Model(inputs=[state], outputs=w)
elif modeltype == 'conv1':
def init(): return keras.initializers.RandomNormal(mean=0.0, stddev=.003, seed=np.random.randint(2**32))
conv1 = Conv2D(8, (2,2), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init())
pool1 = MaxPool2D(data_format='channels_first')
conv2 = Conv2D(16, (2,2), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init())
pool2 = MaxPool2D(data_format='channels_first')
flat1 = Flatten(name='flattened')
out = Dense(1, activation='linear',kernel_initializer=init(), bias_initializer=init())
output = Lambda(lambda x: tf.exp(tf.clip_by_value(x,-10,10)))
w = output(out(flat1(pool2(conv2(pool1(conv1(state)))))))
w_next = output(out(flat1(pool2(conv2(pool1(conv1(next_state)))))))
trainable_model = keras.models.Model(inputs=[state,next_state,policy_ratio,isStart,median_dist], outputs=[w])
w_model = keras.models.Model(inputs=[state], outputs=w)
elif modeltype == 'linear':
def init(): return keras.initializers.RandomNormal(mean=0.0, stddev=.003, seed=np.random.randint(2**32))
dense1 = Dense(1, activation='linear', name='out',kernel_initializer=init(), bias_initializer=keras.initializers.Zeros())
output = Lambda(lambda x: tf.exp(tf.clip_by_value(x,-10,10)))
w = output(dense1(state))
w_next = output(dense1(next_state))
trainable_model = keras.models.Model(inputs=[state,next_state,policy_ratio,isStart,median_dist], outputs=[w])
w_model = keras.models.Model(inputs=[state], outputs=w)
else:
def init(): return keras.initializers.RandomNormal(mean=0.0, stddev=.003, seed=np.random.randint(2**32))
dense1 = Dense(16, activation='relu',kernel_initializer=init(), bias_initializer=keras.initializers.Zeros())
dense2 = Dense(8, activation='relu',kernel_initializer=init(), bias_initializer=keras.initializers.Zeros())
dense3 = Dense(1, activation='linear', name='out',kernel_initializer=init(), bias_initializer=keras.initializers.Zeros())
output = Lambda(lambda x: tf.exp(tf.clip_by_value(x,-10,10)))
w = output(dense3(dense2(dense1(state))))
w_next = output(dense3(dense2(dense1(next_state))))
trainable_model = keras.models.Model(inputs=[state,next_state,policy_ratio,isStart,median_dist], outputs=[w])
w_model = keras.models.Model(inputs=[state], outputs=w)
# rmsprop = keras.optimizers.RMSprop(lr=0.001, rho=0.95, epsilon=1e-08, decay=1e-3)#, clipnorm=1.)
adam = keras.optimizers.Adam()
trainable_model.add_loss(self.IH_loss(next_state,w,w_next,policy_ratio,isStart, median_dist, self.modeltype))
trainable_model.compile(loss=None, optimizer=adam, metrics=['accuracy'])
return trainable_model, w_model
@staticmethod
def IH_loss(next_state, w, w_next,policy_ratio,isStart, med_dist, modeltype):
# change from tf to K.backend?
norm_w = tf.reduce_mean(w)
# calculate loss function
x = (1-isStart) * w * policy_ratio + isStart * norm_w - w_next
x = tf.reshape(x,[-1,1])
diff_xx = tf.expand_dims(next_state, 0) - tf.expand_dims(next_state, 1)
if modeltype in ['conv', 'conv1']:
K_xx = tf.exp(-tf.reduce_sum(tf.square(diff_xx),axis=[-1, -2, -3])/(2.0*med_dist*med_dist))#*med_dist))
else:
K_xx = tf.exp(-tf.reduce_sum(tf.square(diff_xx),axis=[-1])/(2.0*med_dist*med_dist))#*med_dist))
loss_xx = tf.matmul(tf.matmul(tf.transpose(x),K_xx),x)#/(n_x*n_x)
loss = tf.squeeze(loss_xx)/(norm_w*norm_w)
return tf.reduce_mean(loss)
def run_NN(self, env, max_epochs, batch_size, epsilon=0.001, modeltype_overwrite =None):
self.dim_of_actions = env.n_actions
self.Q_k = None
# earlyStopping = EarlyStopping(monitor='val_loss', min_delta=1e-4, patience=10, verbose=1, mode='min', restore_best_weights=True)
# reduce_lr_loss = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=7, verbose=1, min_delta=1e-4, mode='min')
self.more_callbacks = [] #[earlyStopping, reduce_lr_loss]
im = self.data.states()[0]
if self.processor: im = self.processor(im)
if self.modeltype in ['conv', 'conv1']:
trainable_model, state_to_w = self.build_model(im.shape[1:], 'w', modeltype=modeltype_overwrite if modeltype_overwrite is not None else self.modeltype)
state_to_w.predict([im])
self.state_to_w = state_to_w
self.trainable_model = trainable_model
else:
trainable_model, state_to_w = self.build_model((np.prod(im.shape[1:]),), 'w', modeltype=self.modeltype)
state_to_w.predict([[im[0].reshape(-1)]])
self.state_to_w = state_to_w
self.trainable_model = trainable_model
values = []
print('Training: IH')
losses = []
for k in tqdm(range(max_epochs)):
dataset_length = self.data.num_tuples()
perm = np.random.permutation(range(dataset_length))
eighty_percent_of_set = int(1.*len(perm))
training_idxs = perm[:eighty_percent_of_set]
validation_idxs = perm[eighty_percent_of_set:]
training_steps_per_epoch = max(500, int(.03 * np.ceil(len(training_idxs)/float(batch_size))))
# training_steps_per_epoch = 1 #int(1. * np.ceil(len(training_idxs)/float(batch_size)))
validation_steps_per_epoch = int(np.ceil(len(validation_idxs)/float(batch_size)))
train_gen = self.generator(env, training_idxs, fixed_permutation=True, batch_size=batch_size)
# val_gen = self.generator(env, validation_idxs, fixed_permutation=True, batch_size=batch_size)
M = 5
hist = self.trainable_model.fit_generator(train_gen,
steps_per_epoch=training_steps_per_epoch,
# validation_data=val_gen,
# validation_steps=validation_steps_per_epoch,
epochs=max_epochs,
max_queue_size=50,
workers=1,
use_multiprocessing=False,
verbose=1,
callbacks = self.more_callbacks)
return state_to_w
# return np.mean(values[-10:]), self.Q_k, self.Q_k_all
def euclidean(self, X, Y):
distance = np.zeros((len(X), len(Y)))
for row,x in enumerate(X):
for col,y in enumerate(Y):
y_row,y_col = np.unravel_index(np.argmin(y.reshape(-1), y.shape))
x_row,x_col = np.unravel_index(np.argmin(y.reshape(-1), y.shape))
distance = np.sqrt((x_row-y_row)**2 + (x_col+y_col)**2)
return distance
@threadsafe_generator
def generator(self, env, all_idxs, fixed_permutation=False, batch_size = 64):
data_length = len(all_idxs)
steps = int(np.ceil(data_length/float(batch_size)))
n = len(self.data)
T = max(self.data.lengths())
n_dim = self.data.n_dim
n_actions = self.data.n_actions
S = np.hstack([self.data.states()[:,[0]], self.data.states()])
SN = np.hstack([self.data.states()[:,[0]], self.data.next_states()])
PI0 = np.hstack([self.data.base_propensity()[:,[0]], self.data.base_propensity()])
PI1 = np.hstack([self.data.target_propensity()[:,[0]], self.data.target_propensity()])
ACTS = np.hstack([np.zeros_like(self.data.actions()[:,[0]]), self.data.actions()])
pi0 = []
pi1 = []
for i in range(len(ACTS)):
pi0_ = []
pi1_ = []
for j in range(len(ACTS[1])):
a = ACTS[i,j]
pi0_.append(PI0[i,j,a])
pi1_.append(PI1[i,j,a])
pi0.append(pi0_)
pi1.append(pi1_)
PI0 = np.array(pi0)
PI1 = np.array(pi1)
REW = np.hstack([np.zeros_like(self.data.rewards()[:,[0]]), self.data.rewards()])
ISSTART = np.zeros_like(REW)
ISSTART[:,0] = 1.
PROBS = np.repeat(np.atleast_2d(self.gamma**np.arange(-1,REW.shape[1]-1)), REW.shape[0], axis=0).reshape(REW.shape)
S = np.vstack(S)
SN = np.vstack(SN)
PI1 = PI1.reshape(-1)
PI0 = PI0.reshape(-1)
ISSTART = ISSTART.reshape(-1)
PROBS = PROBS.reshape(-1)
PROBS /= sum(PROBS)
N = S.shape[0]
subsamples = np.random.choice(N, len(S))
bs = batch_size
num_batches = max(len(subsamples) // bs,1)
med_dist = []
for batch_num in tqdm(range(num_batches)):
low_ = batch_num * bs
high_ = (batch_num + 1) * bs
sub = subsamples[low_:high_]
if self.modeltype in ['conv']:
s = self.processor(S[sub])
else:
s = S[sub].reshape(len(sub),-1)[...,None,None]
med_dist.append(np.sum(np.square(s[None, :, :] - s[:, None, :]), axis = tuple([-3,-2,-1])))
med_dist = np.sqrt(np.median(np.array(med_dist).reshape(-1)[np.array(med_dist).reshape(-1) > 0]))
while True:
# perm = np.random.permutation(all_idxs)
for batch in np.arange(steps):
# batch_idxs = perm[(batch*batch_size):((batch+1)*batch_size)]
batch_idxs = np.random.choice(S.shape[0], batch_size, p=PROBS)
if self.modeltype in ['conv', 'conv1']:
state = self.processor(S[batch_idxs])
next_state = self.processor(SN[batch_idxs])
else:
state = S[batch_idxs].reshape(len(batch_idxs),-1)#[...,None,None]
next_state = SN[batch_idxs].reshape(len(batch_idxs),-1)#[...,None,None]
policy_ratio = PI1[batch_idxs] / PI0[batch_idxs]
isStart = ISSTART[batch_idxs]
median_dist = np.repeat(med_dist, batch_size)
yield ([state,next_state,policy_ratio,isStart,median_dist], [])
def estimate_density_ratios(self, env, max_epochs, matrix_size):
dataset = self.data
if self.is_discrete:
S = np.squeeze(dataset.states())
SN = np.squeeze(dataset.next_states())
PI0 = dataset.base_propensity()
PI1 = dataset.target_propensity()
REW = dataset.rewards()
ACTS = dataset.actions()
self.den_discrete.reset()
for episode in range(len(S)):
discounted_t = 1.0
initial_state = S[episode][0]
for (s,a,sn,r,pi1,pi0) in zip(S[episode],ACTS[episode],SN[episode], REW[episode], PI1[episode], PI0[episode]):
discounted_t *= self.gamma
policy_ratio = (pi1/pi0)[a]
self.den_discrete.feed_data(s, sn, initial_state, policy_ratio, discounted_t)
self.den_discrete.feed_data(-1, initial_state, initial_state, 1, 1-discounted_t)
x, w = self.den_discrete.density_ratio_estimate()
return w[S]
else:
batch_size = matrix_size
# Here Linear = linear NN
self.state_to_w = self.run_NN(env, max_epochs, batch_size, epsilon=0.001)
S = np.vstack(self.data.states())
ACTS = self.data.actions()
REW = self.data.rewards().reshape(-1)
PI0 = self.probs_per_action(self.data.base_propensity(), ACTS).reshape(-1)
PI1 = self.probs_per_action(self.data.target_propensity(), ACTS).reshape(-1)
predict_batch_size = max(128, batch_size)
steps = int(np.ceil(S.shape[0]/float(predict_batch_size)))
densities = []
for batch in np.arange(steps):
batch_idxs = np.arange(S.shape[0])[(batch*predict_batch_size):((batch+1)*predict_batch_size)]
if self.modeltype in ['conv', 'conv1']:
s = self.processor(S[batch_idxs])
densities.append(self.state_to_w.predict(s))
else:
s = S[batch_idxs]
s = s.reshape(s.shape[0], -1)
densities.append(self.state_to_w.predict(s))
densities = np.vstack(densities).reshape(-1)
return densities.reshape(self.data.states().shape)
def get_probs_per_action(self, P, A):
pi = []
for i in range(len(A)):
pi_ = []
for j in range(len(A[1])):
pi_.append(P[i,j,A[i,j]])
pi.append(pi_)
return np.array(pi)
def evaluate(self, env, max_epochs, matrix_size):
dataset = self.data
if self.is_discrete:
REW = dataset.rewards()
ACTS = dataset.actions()
W = self.estimate_density_ratios(env, max_epochs, matrix_size)
PI0 = self.get_probs_per_action(dataset.base_propensity(), ACTS)
PI1 = self.get_probs_per_action(dataset.target_propensity(), ACTS)
DISC_FACTORS = np.repeat(np.atleast_2d(self.gamma**np.arange(REW.shape[1])), REW.shape[0], axis=0).reshape(REW.shape)
return self.off_policy_estimator_density_ratio(REW, DISC_FACTORS, (PI1/PI0), W)
else:
batch_size = matrix_size
# Here Linear = linear NN
self.state_to_w = self.run_NN(env, max_epochs, batch_size, epsilon=0.001)
S = self.data.states() #np.hstack([self.data.states()[:,[0]], self.data.states()])
ACTS = self.data.actions() #np.hstack([np.zeros_like(self.data.actions()[:,[0]]), self.data.actions()])
PI0 = self.get_probs_per_action(self.data.base_propensity(), ACTS)
PI1 = self.get_probs_per_action(self.data.target_propensity(), ACTS)
REW = self.data.rewards() #np.hstack([np.zeros_like(self.data.rewards()[:,[0]]), self.data.rewards()])
DISC_FACTORS = np.repeat(np.atleast_2d(self.gamma**np.arange(REW.shape[1])), REW.shape[0], axis=0).reshape(REW.shape)
S = np.vstack(S)
PI1 = PI1.reshape(-1)
PI0 = PI0.reshape(-1)
REW = REW.reshape(-1)
DISC_FACTORS = DISC_FACTORS.reshape(-1)
predict_batch_size = max(128, batch_size)
steps = int(np.ceil(S.shape[0]/float(predict_batch_size)))
densities = []
for batch in np.arange(steps):
batch_idxs = np.arange(S.shape[0])[(batch*predict_batch_size):((batch+1)*predict_batch_size)]
if self.modeltype in ['conv', 'conv1']:
s = self.processor(S[batch_idxs])
densities.append(self.state_to_w.predict(s))
else:
s = S[batch_idxs]
s = s.reshape(s.shape[0], -1)
densities.append(self.state_to_w.predict(s))
densities = np.vstack(densities).reshape(-1)
return self.off_policy_estimator_density_ratio(REW, DISC_FACTORS, PI1/PI0, densities)
@staticmethod
def off_policy_estimator_density_ratio(rew, prob, ratio, den_r):
return np.sum(prob * den_r * ratio * rew)/np.sum(prob * den_r * ratio)
def get_model_params(self):
# get trainable params.
model_names = []
model_params = []
model_shapes = []
with self.g.as_default():
t_vars = tf.trainable_variables()
for var in t_vars:
if var.name.startswith('infhorizon'):
param_name = var.name
p = self.sess.run(var)
model_names.append(param_name)
params = np.round(p*10000).astype(np.int).tolist()
model_params.append(params)
model_shapes.append(p.shape)
return model_params, model_shapes, model_names
def set_model_params(self, params):
with self.g.as_default():
t_vars = tf.trainable_variables()
idx = 0
for var in t_vars:
if var.name.startswith('infhorizon'):
pshape = tuple(var.get_shape().as_list())
p = np.array(params[idx])
assert pshape == p.shape, "inconsistent shape"
assign_op, pl = self.assign_ops[var]
self.sess.run(assign_op, feed_dict={pl.name: p/10000.})
idx += 1
def load_json(self, jsonfile='infhorizon.json'):
with open(jsonfile, 'r') as f:
params = json.load(f)
self.set_model_params(params)
def save_json(self, jsonfile='infhorizon.json'):
model_params, model_shapes, model_names = self.get_model_params()
qparams = []
for p in model_params:
qparams.append(p)
with open(jsonfile, 'wt') as outfile:
json.dump(qparams, outfile, sort_keys=True, indent=0, separators=(',', ': '))
def linear_solver(n, M):
M -= np.amin(M) # Let zero sum game at least with nonnegative payoff
c = np.ones((n))
b = np.ones((n))
res = linprog(-c, A_ub = M.T, b_ub = b)
w = res.x
return w/np.sum(w)
def quadratic_solver(n, M, regularizer):
qp_G = np.matmul(M, M.T)
qp_G += regularizer * np.eye(n)
qp_a = np.zeros(n, dtype = np.float64)
qp_C = np.zeros((n,n+1), dtype = np.float64)
for i in range(n):
qp_C[i,0] = 1.0
qp_C[i,i+1] = 1.0
qp_b = np.zeros(n+1, dtype = np.float64)
qp_b[0] = 1.0
meq = 1
res = quadprog.solve_qp(qp_G, qp_a, qp_C, qp_b, meq)
w = res[0]
return w
class Density_Ratio_discounted(object):
def __init__(self, num_state, gamma):
self.num_state = num_state
self.Ghat = np.zeros([num_state, num_state], dtype = np.float64)
self.Nstate = np.zeros([num_state, 1], dtype = np.float64)
self.initial_b = np.zeros([num_state], dtype = np.float64)
self.gamma = gamma
def reset(self):
num_state = self.num_state
self.Ghat = np.zeros([num_state, num_state], dtype = np.float64)
self.Nstate = np.zeros([num_state, 1], dtype = np.float64)
def feed_data(self, cur, next, initial, policy_ratio, discounted_t):
if cur == -1:
self.Ghat[next, next] -= discounted_t
else:
self.Ghat[cur, next] += policy_ratio * discounted_t
self.Ghat[cur, initial] += (1-self.gamma)/self.gamma * discounted_t
self.Ghat[next, next] -= discounted_t
self.Nstate[cur] += discounted_t
def density_ratio_estimate(self, regularizer = 0.001):
Frequency = self.Nstate.reshape(-1)
tvalid = np.where(Frequency >= 1e-20)
G = np.zeros_like(self.Ghat)
Frequency = Frequency/np.sum(Frequency)
G[tvalid] = self.Ghat[tvalid]/(Frequency[:,None])[tvalid]
n = self.num_state
# x is estimated stationary distribution of pi
# Frequency is estimates stationary distribution of pi_0
x = quadratic_solver(n, G/50.0, regularizer)
w = np.zeros(self.num_state)
w[tvalid] = x[tvalid]/Frequency[tvalid]
return x, w
| 22,869 | 43.755382 | 167 | py |
SOPE | SOPE-master/ope/algos/retrace_lambda.py | import sys
import numpy as np
import pandas as pd
from copy import deepcopy
from keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
import keras
from keras.models import Sequential
from keras.layers import Dense, Conv2D, Flatten, MaxPool2D, concatenate, UpSampling2D, Reshape, Lambda
from keras.optimizers import Adam
from keras import backend as K
import tensorflow as tf
from tqdm import tqdm
from ope.utls.thread_safe import threadsafe_generator
from keras import regularizers
from sklearn.linear_model import LinearRegression, LogisticRegression
class Retrace(object):
def __init__(self, data, gamma, frameskip=1, frameheight=1, modeltype='linear', lamb=1., processor=None, max_iters=500):
self.data = data
self.gamma = gamma
self.lamb = lamb
self.frameskip= frameskip
self.frameheight = frameheight
self.modeltype = modeltype
self.processor = processor
self.max_iters = max_iters
def run(self, pi_b, pi_e, method, epsilon=0.001, lamb=None, verbose=True, diverging_epsilon=1000):
lamb = lamb if lamb is not None else self.lamb
assert method in ['retrace','tree-backup','Q^pi(lambda)','IS']
S = np.squeeze(self.data.states())
SN = np.squeeze(self.data.next_states())
ACTS = self.data.actions()
REW = self.data.rewards()
PIE = self.data.target_propensity()
PIB = self.data.base_propensity()
DONES = self.data.dones()
unique_states = np.unique(np.vstack([S, SN]))
state_space_dim = len(unique_states)
action_space_dim = pi_e.action_space_dim
U1 = np.zeros(shape=(state_space_dim,action_space_dim))
mapping = {state:idx for idx,state in enumerate(unique_states)}
state_action_to_idx = {}
for row,SA in enumerate(zip(S,ACTS)):
for col, (state,action) in enumerate(zip(*SA)):
if tuple([state,action]) not in state_action_to_idx: state_action_to_idx[tuple([state,action])] = []
state_action_to_idx[ tuple([state,action]) ].append([row, col])
count = 0
eps = 1e-8
while True:
U = U1.copy()
update = np.zeros(shape=(state_space_dim,action_space_dim))
delta = 0
out = []
for s,a,r,sn,pie,pib,done in zip(S,ACTS,REW,SN,PIE,PIB,DONES):
t = len(s)
s = np.array([mapping[s_] for s_ in s])
sn = np.array([mapping[s_] for s_ in sn])
if method == 'retrace':
c = pie[range(len(a)), a]/(pib[range(len(a)), a] + eps)
c[0] = 1.
c = lamb * np.minimum(1., c) # c_s = lambda * min(1, pie/pib)
elif method == 'tree-backup':
c = lamb * pie[range(len(a)), a] # c_s = lambda * pi(a|x)
c[0] = 1.
elif method == 'Q^pi(lambda)':
c = np.ones_like(a)*lamb # c_s = lambda
c[0] = 1.
elif method == 'IS':
c = pie[range(len(a)), a]/(pib[range(len(a)), a] + eps) # c_s = pie/pib
c[0] = 1.
c = c # c_s = pie/pib
else:
raise
c = np.cumprod(c)
gam = self.gamma ** np.arange(t)
expected_U = np.sum(pi_e.predict(sn)*U[sn, :], axis=1)*(1-done)
# expected_U = np.sum([], axu
diff = r + self.gamma * expected_U - U[s, a]
# import pdb; pdb.set_trace()
val = gam * c * diff
out.append(np.cumsum(val[::-1])[::-1])
out = np.array(out)
for key, val in state_action_to_idx.items():
rows, cols = np.array(val)[:,0], np.array(val)[:,1]
state, action = key[0], key[1]
state = mapping[state]
update[state, action] = np.mean(out[rows,cols])
U1 = U1 + update
delta = np.linalg.norm(U-U1)
count += 1
if verbose: print(count, delta)
if delta < epsilon or count > self.max_iters or delta > diverging_epsilon:# * (1 - self.gamma) / self.gamma:
return np.sum([prob*U1[0, new_a] for new_a,prob in enumerate(pi_e.predict([0])[0])]), U1, mapping #U[0,pi_e([0])][0]
@staticmethod
def build_model(input_size, scope, action_space_dim=3, modeltype='conv'):
inp = keras.layers.Input(input_size, name='frames')
actions = keras.layers.Input((action_space_dim,), name='mask')
def init(): return keras.initializers.TruncatedNormal(mean=0.0, stddev=0.001, seed=np.random.randint(2**32))
if modeltype == 'conv':
conv1 = Conv2D(8, (7,7), strides=(3,3), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(inp)
pool1 = MaxPool2D(data_format='channels_first')(conv1)
conv2 = Conv2D(16, (3,3), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(pool1)
pool2 = MaxPool2D(data_format='channels_first')(conv2)
flat1 = Flatten(name='flattened')(pool2)
out = Dense(256, activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(flat1)
elif modeltype == 'conv1':
def init(): return keras.initializers.TruncatedNormal(mean=0.0, stddev=0.001, seed=np.random.randint(2**32))
conv1 = Conv2D(16, (2,2), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(inp)
# pool1 = MaxPool2D(data_format='channels_first')(conv1)
# conv2 = Conv2D(16, (2,2), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(pool1)
# pool2 = MaxPool2D(data_format='channels_first')(conv2)
flat1 = Flatten(name='flattened')(conv1)
out = Dense(8, activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(flat1)
out = Dense(8, activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(out)
elif modeltype == 'mlp':
def init(): return keras.initializers.TruncatedNormal(mean=0.0, stddev=.1, seed=np.random.randint(2**32))
flat = Flatten()(inp)
dense1 = Dense(16, activation='relu',kernel_initializer=init(), bias_initializer=init())(flat)
# dense2 = Dense(256, activation='relu',kernel_initializer=init(), bias_initializer=init())(dense1)
dense3 = Dense(8, activation='relu',kernel_initializer=init(), bias_initializer=init())(dense1)
out = Dense(4, activation='relu', name='out',kernel_initializer=init(), bias_initializer=init())(dense3)
elif modeltype == 'linear':
def init(): return keras.initializers.TruncatedNormal(mean=0.0, stddev=.001, seed=np.random.randint(2**32))
out = Flatten()(inp)
else:
raise NotImplemented
all_actions = Dense(action_space_dim, name=scope + 'all_Q', activation="linear",kernel_initializer=init(), bias_initializer=init())(out)
output = keras.layers.dot([all_actions, actions], 1)
model = keras.models.Model(inputs=[inp, actions], outputs=output)
all_Q = keras.models.Model(inputs=[inp],
outputs=model.get_layer(scope + 'all_Q').output)
rmsprop = keras.optimizers.RMSprop(lr=0.05, rho=0.95, epsilon=1e-08, decay=1e-3)#, clipnorm=1.)
adam = keras.optimizers.Adam(clipnorm=1.)
model.compile(loss='mse', optimizer=adam, metrics=['accuracy'])
return model, all_Q
@staticmethod
def copy_over_to(source, target):
target.set_weights(source.get_weights())
@staticmethod
def weight_change_norm(model, target_model):
norm_list = []
number_of_layers = len(model.layers)
for i in range(number_of_layers):
model_matrix = model.layers[i].get_weights()
target_model_matrix = target_model.layers[i].get_weights()
if len(model_matrix) >0:
#print "layer ", i, " has shape ", model_matrix[0].shape
if model_matrix[0].shape[0] > 0:
norm_change = np.linalg.norm(model_matrix[0]-target_model_matrix[0])
norm_list.append(norm_change)
return sum(norm_list)*1.0/len(norm_list)
# def run_linear(self, env, method, pi_b, pi_e, max_epochs, epsilon=.001, lamb=.5):
# lamb = lamb if lamb is not None else self.lamb
# assert method in ['retrace','tree-backup','Q^pi(lambda)','IS']
# S = np.squeeze(self.data.states())
# SN = np.squeeze(self.data.next_states())
# ACTS = self.data.actions()
# REW = self.data.rewards()
# PIE = self.data.target_propensity()
# PIB = self.data.base_propensity()
# DONES = self.data.dones()
# action_space_dim = env.n_actions
# ACTS_reshaped = np.eye(action_space_dim)[ACTS.reshape(-1)]
# self.Q_k = LinearRegression()
# for epoch in tqdm(range(max_epochs)):
# X = np.hstack([S.reshape(np.hstack([-1, np.prod(S.shape[2:])])) , ACTS_reshaped])
# if epoch > 0:
# Q_ = self.Q_k.predict(X)
# delta = np.linalg.norm(Q_ - Q)
# print(Q_-Q)
# print(delta)
# Q = Q_
# else:
# Q = 0
# out=[]
# for traj_num, (s,a,r,sn,pie,pib,done) in enumerate(zip(S,ACTS,REW,SN,PIE,PIB,DONES)):
# t = len(s)
# prev_shape = s.shape
# s = s.reshape(np.hstack([-1, np.prod(s.shape[1:])]))
# sn = sn.reshape(np.hstack([-1, np.prod(sn.shape[1:])]))
# if method == 'retrace':
# c = pie[range(len(a)), a]/pib[range(len(a)), a]
# c[0] = 1.
# c = lamb * np.minimum(1., c) # c_s = lambda * min(1, pie/pib)
# elif method == 'tree-backup':
# c = lamb * pie[range(len(a)), a] # c_s = lambda * pi(a|x)
# c[0] = 1.
# elif method == 'Q^pi(lambda)':
# c = np.ones_like(a)*lamb # c_s = lambda
# c[0] = 1.
# elif method == 'IS':
# c = pie[range(len(a)), a]/pib[range(len(a)), a] # c_s = pie/pib
# c[0] = 1.
# c = c # c_s = pie/pib
# else:
# raise
# c = np.cumprod(c)
# gam = self.gamma ** np.arange(t)
# if epoch == 0:
# diff = r
# else:
# # E_{\pi_e}[Q(x_{t+1}, .)]
# expected_U = np.sum([pi_e.predict(s.reshape(prev_shape))[0][act]*self.Q_k.predict(np.hstack([sn, np.tile(np.eye(action_space_dim)[act], len(sn)).reshape(len(sn),action_space_dim) ]))*(1-done) for act in np.arange(action_space_dim)], axis=0)
# # r + gamma * E_{\pi_e}[Q(x_{t+1}, .)] - Q(x_t, a_t)
# diff = r + self.gamma * expected_U - self.Q_k.predict(np.hstack([s, np.eye(action_space_dim)[a]])) # Q.reshape(REW.shape)[traj_num].reshape(-1)#
# # import pdb; pdb.set_trace()
# val = gam * c * diff
# out.append(np.cumsum(val[::-1])[::-1])
# out = np.array(out)
# self.Q_k.fit(X, Q + out.reshape(-1))
# return self.Q_k
def run_NN(self, env, pi_b, pi_e, max_epochs, method, epsilon=0.001):
initial_states = self.data.initial_states()
if self.processor: initial_states = self.processor(initial_states)
self.dim_of_actions = env.n_actions
self.Q_k = None
self.Q_k_all = None
self.Q_k_minus_1 = None
self.Q_k_minus_1_all = None
# earlyStopping = EarlyStopping(monitor='val_loss', min_delta=1e-4, patience=10, verbose=1, mode='min', restore_best_weights=True)
# mcp_save = ModelCheckpoint('fqe.hdf5', save_best_only=True, monitor='val_loss', mode='min')
# reduce_lr_loss = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=7, verbose=1, min_delta=1e-4, mode='min')
self.more_callbacks = [] #[earlyStopping, mcp_save, reduce_lr_loss]
# if self.modeltype == 'conv':
# im = env.pos_to_image(np.array(self.trajectories[0]['x'][0])[np.newaxis,...])
# else:
# im = np.array(self.trajectories[0]['frames'])[np.array(self.trajectories[0]['x'][0]).astype(int)][np.newaxis,...]
im = self.data.states()[0]
if self.processor: im = self.processor(im)
self.Q_k, self.Q_k_all = self.build_model(im.shape[1:], 'Q_k', modeltype=self.modeltype, action_space_dim=env.n_actions)
self.Q_k_minus_1, self.Q_k_minus_1_all = self.build_model(im.shape[1:], 'Q_k_minus_1', modeltype=self.modeltype, action_space_dim=env.n_actions)
# print('testing Q_k:', )
tmp_act = np.eye(env.n_actions)[[0]]
self.Q_k.predict([[im[0]], tmp_act])
# print('testing Q_k all:', )
self.Q_k_all.predict([[im[0]]])
# print('testing Q_k_minus_1:', )
self.Q_k_minus_1.predict([[im[0]], tmp_act])
# print('testing Q_k_minus_1 all:', )
self.Q_k_minus_1_all.predict([[im[0]]])
self.copy_over_to(self.Q_k, self.Q_k_minus_1)
values = []
print('Training: %s' % method)
losses = []
for k in tqdm(range(max_epochs)):
batch_size = 4
dataset_length = self.data.num_tuples()
perm = np.random.permutation(range(dataset_length))
eighty_percent_of_set = int(1.*len(perm))
training_idxs = perm[:eighty_percent_of_set]
validation_idxs = perm[eighty_percent_of_set:]
training_steps_per_epoch = max(500, int(.03 * np.ceil(len(training_idxs)/float(batch_size))))
validation_steps_per_epoch = int(np.ceil(len(validation_idxs)/float(batch_size)))
# steps_per_epoch = 1 #int(np.ceil(len(dataset)/float(batch_size)))
train_gen = self.generator(env, pi_e, training_idxs, method, fixed_permutation=True, batch_size=batch_size)
# val_gen = self.generator(policy, dataset, validation_idxs, method, fixed_permutation=True, batch_size=batch_size)
# import pdb; pdb.set_trace()
# train_gen = self.generator(env, pi_e, (transitions,frames), training_idxs, fixed_permutation=True, batch_size=batch_size)
# inp, out = next(train_gen)
M = 5
hist = self.Q_k.fit_generator(train_gen,
steps_per_epoch=training_steps_per_epoch,
#validation_data=val_gen,
#validation_steps=validation_steps_per_epoch,
epochs=1,
max_queue_size=50,
workers=2,
use_multiprocessing=False,
verbose=1,
callbacks = self.more_callbacks)
norm_change = self.weight_change_norm(self.Q_k, self.Q_k_minus_1)
self.copy_over_to(self.Q_k, self.Q_k_minus_1)
losses.append(hist.history['loss'])
actions = pi_e.sample(initial_states)
assert len(actions) == initial_states.shape[0]
Q_val = self.Q_k_all.predict(initial_states)[np.arange(len(actions)), actions]
values.append(np.mean(Q_val))
print(values[-1], norm_change, np.mean(values[-M:]), np.abs(np.mean(values[-M:])- np.mean(values[-(M+1):-1])), 1e-4*np.abs(np.mean(values[-(M+1):-1])))
if k>M and np.abs(np.mean(values[-M:]) - np.mean(values[-(M+1):-1])) < 1e-4*np.abs(np.mean(values[-(M+1):-1])):
break
return np.mean(values[-10:]), self.Q_k, self.Q_k_all
# actions = policy(initial_states[:,np.newaxis,...], x_preprocessed=True)
# Q_val = self.Q_k.all_actions([initial_states], x_preprocessed=True)[np.arange(len(actions)), actions]
# return np.mean(Q_val)*dataset.scale, values
@threadsafe_generator
def generator(self, env, pi_e, all_idxs, method, fixed_permutation=False, batch_size = 64):
# dataset, frames = dataset
data_length = len(all_idxs)
steps = int(np.ceil(data_length/float(batch_size)))
states = self.data.states()
# states = states.reshape(-1,np.prod(states.shape[2:]))
actions = self.data.actions()
# actions = np.eye(env.n_actions)[actions]
next_states = self.data.next_states()
original_shape = next_states.shape
next_states = next_states.reshape(-1,np.prod(next_states.shape[2:]))
pi1_ = self.data.next_target_propensity()
pi1 = self.data.target_propensity()
pi0 = self.data.base_propensity()
rewards = self.data.rewards()
dones = self.data.dones()
alpha = 1.
# balance dataset since majority of dataset is absorbing state
probs = np.hstack([np.zeros((dones.shape[0],2)), dones,])[:,:-2]
if np.sum(probs):
done_probs = probs / np.sum(probs)
probs = 1 - probs + done_probs
else:
probs = 1 - probs
probs = probs.reshape(-1)
probs /= np.sum(probs)
# probs = probs[all_idxs]
while True:
batch_idxs = np.random.choice(all_idxs, batch_size, p = probs)
Ss = []
As = []
Ys = []
for idx in batch_idxs:
traj_num = int(idx/ self.data.lengths()[0]) # Assume fixed length, horizon is fixed
i = idx - traj_num * self.data.lengths()[0]
s = self.data.states(low_=traj_num, high_=traj_num+1)[0,i:]
sn = self.data.next_states(low_=traj_num, high_=traj_num+1)[0,i:]
a = actions[traj_num][i:]
r = rewards[traj_num][i:]
pie = pi1[traj_num][i:]
pie_ = pi1_[traj_num][i:]
pib = pi0[traj_num][i:]
if method == 'retrace':
c = pie[range(len(a)), a]/pib[range(len(a)), a]
c[0] = 1.
c = self.lamb * np.minimum(1., c) # c_s = lambda * min(1, pie/pib)
elif method == 'tree-backup':
c = self.lamb * pie[range(len(a)), a] # c_s = lambda * pi(a|x)
c[0] = 1.
elif method == 'Q^pi(lambda)':
c = np.ones_like(a)*self.lamb # c_s = lambda
c[0] = 1.
elif method == 'IS':
c = pie[range(len(a)), a]/pib[range(len(a)), a] # c_s = pie/pib
c[0] = 1.
c = c # c_s = pie/pib
else:
raise
c = np.cumprod(c)
gam = self.gamma ** np.arange(len(s))
if self.processor:
s = self.processor(s)
sn = self.processor(sn)
Q_x = self.Q_k_minus_1_all.predict(s)
Q_x_ = self.Q_k_minus_1_all.predict(sn)
Q_xt_at = Q_x[range(len(a)), a]
E_Q_x_ = np.sum(Q_x_*pie_, axis=1)
Ss.append(s[0])
As.append(a[0])
Ys.append(Q_xt_at[0] + np.sum(gam * c * (r + self.gamma * E_Q_x_ - Q_xt_at)))
yield [np.array(Ss), np.eye(env.n_actions)[np.array(As)]], [np.array(Ys)]
| 20,225 | 45.283753 | 262 | py |
SOPE | SOPE-master/ope/algos/approximate_model.py |
from ope.algos.direct_method import DirectMethodModelBased
import numpy as np
import scipy.signal as signal
from ope.utls.thread_safe import threadsafe_generator
import os
import time
from copy import deepcopy
from sklearn.linear_model import LinearRegression, LogisticRegression
from tqdm import tqdm
import torch
torch.backends.cudnn.benchmark = True
import torch.nn as nn
import torch.optim as optim
import torch.autograd as autograd
import torch.nn.functional as F
torch.autograd.set_detect_anomaly(True)
class ApproxModel(DirectMethodModelBased):
"""Algorithm: Approx Model (Model-Based).
This is class builds a model from which Q can be estimated through rollouts.
"""
def __init__(self, cfg, n_actions):
DirectMethodModelBased.__init__(self)
self.frameheight = cfg.frameheight
self.frameskip = cfg.frameskip
self.max_traj_length = cfg.models['MBased']['max_traj_length']
self.override_done = True if self.max_traj_length is not None else False
self.n_actions = n_actions
def fit_NN(self, data, pi_e, config, verbose=True) -> float:
cfg = config.models['MBased']
processor = config.processor
# TODO: early stopping + lr reduction
im = data.states()[0]
if processor: im = processor(im)
self.model = cfg['model'](im.shape[1:], data.n_actions)
optimizer = optim.Adam(self.model.parameters())
print('Training: Model Free')
losses = []
batch_size = cfg['batch_size']
dataset_length = data.num_tuples()
perm = np.random.permutation(range(dataset_length))
eighty_percent_of_set = int(.8*len(perm))
training_idxs = perm[:eighty_percent_of_set]
validation_idxs = perm[eighty_percent_of_set:]
training_steps_per_epoch = int(1.*np.ceil(len(training_idxs)/float(batch_size)))
validation_steps_per_epoch = int(np.ceil(len(validation_idxs)/float(batch_size)))
for k in tqdm(range(cfg['max_epochs'])):
train_gen = self.generator(data, config, training_idxs, fixed_permutation=True, batch_size=batch_size, processor=processor)
val_gen = self.generator(data, config, training_idxs, fixed_permutation=True, batch_size=batch_size, processor=processor)
M = 5
for step in range(training_steps_per_epoch):
with torch.no_grad():
inp, out = next(train_gen)
states = torch.from_numpy(inp[0]).float()
actions = torch.from_numpy(inp[1]).bool()
next_states = torch.from_numpy(out[0]).float()
rewards = torch.from_numpy(out[1]).float()
dones = torch.from_numpy(out[2]).float()
pred_next_states, pred_rewards, pred_dones = self.model(states, actions)
states_loss = (pred_next_states - next_states).pow(2).mean()
rewards_loss = (pred_rewards - rewards).pow(2).mean()
dones_loss = nn.BCELoss()(pred_dones, dones)
loss = states_loss + rewards_loss + dones_loss
optimizer.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(self.model.parameters(), cfg['clipnorm'])
optimizer.step()
self.fitted = 'NN'
return 1.0
@threadsafe_generator
def generator(self, data, cfg, all_idxs, fixed_permutation=False, batch_size = 64, processor=None):
"""Data Generator for Model-Based
Parameters
----------
env : obj
The environment object.
all_idxs : ndarray
1D array of ints representing valid datapoints from which we generate examples
batch_size : int
Minibatch size to during training
Yield
-------
obj1, obj2
obj1: [state, action]
obj2: [next state, reward, is done]
"""
data_length = len(all_idxs)
steps = int(np.ceil(data_length/float(batch_size)))
states = data.states()
states_ = data.next_states()
lengths = data.lengths()
rewards = data.rewards().reshape(-1)
actions = data.actions().reshape(-1)
dones = data.dones().reshape(-1)
shp = states.shape
states = states.reshape(np.prod(shp[:2]), -1)
states_ = states_.reshape(np.prod(shp[:2]), -1)
while True:
perm = np.random.permutation(all_idxs)
for batch in np.arange(steps):
batch_idxs = perm[(batch*batch_size):((batch+1)*batch_size)]
x = states[batch_idxs]
x_ = states_[batch_idxs]
r = rewards[batch_idxs]
done = dones[batch_idxs]
act = actions[batch_idxs]
tmp_shp = np.hstack([len(batch_idxs),-1,shp[2:]])
inp = cfg.processor(x.reshape(tmp_shp).squeeze())
inp = inp[:,None,:,:]
out_x_ = np.squeeze((x_-x).reshape(tmp_shp))
out_x_ = out_x_[:,None,:,:]
out_r = -r
out_done = done
# if self.modeltype in ['conv']:
# tmp_shp = np.hstack([len(batch_idxs),-1,shp[2:]])
# inp = self.processor(x.reshape(tmp_shp).squeeze())
# out_x_ = np.diff(self.processor(x_.reshape(tmp_shp)).squeeze(), axis=1)[:,[-1],...]
# out_r = -r
# out_done = done
# elif self.modeltype == 'conv1':
# tmp_shp = np.hstack([len(batch_idxs),-1,shp[2:]])
# inp = self.processor(x.reshape(tmp_shp).squeeze())
# inp = inp[:,None,:,:]
# out_x_ = np.squeeze((x_-x).reshape(tmp_shp))
# out_x_ = out_x_[:,None,:,:]
# out_r = -r
# out_done = done
# else:
# tmp_shp = np.hstack([len(batch_idxs),-1,shp[2:]])
# inp = np.squeeze(x.reshape(tmp_shp))
# out_x_ = x_
# out_x_ = np.diff(out_x_.reshape(tmp_shp), axis=2).reshape(-np.prod(tmp_shp[:2]), -1)
# out_r = -r
# out_done = done
# out_x_ = out_x_[:,None,...]
yield [inp, np.eye(data.n_actions)[act]], [out_x_, out_r, out_done]
# yield ([x, np.eye(3)[acts], np.array(weight).reshape(-1,1)], [np.array(R).reshape(-1,1)])
def transition_NN(self, x, a):
# if isinstance(self.full, list):
# state_diff, r, prob_done = [model.predict(np.hstack([x.reshape(x.shape[0],-1), a])) for model in self.full]
# state_diff = state_diff[:,None,:]
# prob_done = [[d] for d in prob_done]
# else:
#
state_diff, r, prob_done = self.model(torch.from_numpy(x).float(), torch.from_numpy(a).bool())
state_diff = state_diff.detach().numpy()
r = r.detach().numpy()
prob_done = prob_done.detach().numpy()
x_ = np.concatenate([x[:,1:self.frameheight,...], x[:,(self.frameheight-1):self.frameheight,...] + state_diff], axis=1)
done = np.array([np.random.choice([0,1], p=[1-d, d]) for d in prob_done])
return x_, -r.reshape(-1), done
def Q_NN(self, policy, x, gamma, t=0):
"""(Linear/Neural) Return the Model-Based OPE estimate for pi_e starting from a state
Parameters
----------
policy : obj
A policy object, evaluation policy.
x : ndarray
State.
t : int, optional
time
Default: 0
Returns
-------
list
The Q value starting from state x and taking each possible action
in the action space:
[Q(x, a) for a in A]
"""
Qs = []
# state = x
# make action agnostic.
state = np.repeat(x, self.n_actions, axis=0)
acts = np.tile(np.arange(self.n_actions), len(x))
done = np.zeros(len(state))
costs = []
trajectory_length = t
# Q
cost_to_go = np.zeros(len(state))
new_state, cost_holder, new_done = self.transition_NN(state, np.atleast_2d(np.eye(self.n_actions)[acts]))
# cost_holder = self.estimate_R(state, np.atleast_2d(np.eye(self.action_space_dim)[acts]), None)
done = done + new_done
new_cost_to_go = cost_to_go + gamma * cost_holder * (1-done)
norm_change = np.sqrt(np.sum((new_cost_to_go-cost_to_go)**2) / len(state))
# print(trajectory_length, norm_change, cost_to_go, sum(done), len(done))
cost_to_go = new_cost_to_go
if norm_change < 1e-4:
done = np.array([True])
trajectory_length += 1
if self.max_traj_length is not None:
if trajectory_length >= self.max_traj_length:
done = np.array([True])
state = new_state
while not done.all():
tic=time.time()
still_alive = np.where(1-done)[0]
acts = policy.sample(state[still_alive])
new_state, cost_holder, new_done = self.transition_NN(state[still_alive], np.atleast_2d(np.eye(self.n_actions)[acts]))
# cost_holder = self.estimate_R(state, np.atleast_2d(np.eye(self.action_space_dim)[acts]), trajectory_length)
# if (tuple([state,a,new_state]) in self.terminal_transitions):
# done = True
done[still_alive] = (done[still_alive] + new_done).astype(bool)
new_cost_to_go = cost_to_go[still_alive] + gamma * cost_holder * (1-done[still_alive])
# norm_change = np.sqrt(np.sum((new_cost_to_go-cost_to_go)**2) / len(state))
# print(trajectory_length, norm_change, cost_to_go, sum(done), len(done))
cost_to_go[still_alive] = new_cost_to_go
# if norm_change < 1e-4:
# done = np.array([True])
trajectory_length += 1
if self.max_traj_length is not None:
if trajectory_length >= self.max_traj_length:
done = np.array([True])
# print(time.time()-tic, trajectory_length)
state[still_alive] = new_state
return cost_to_go
def fit_tabular(self, dataset, pi_e, config, verbose=True) -> float:
'''
probability of
transitioning from s to s'
given action a is the number of
times this transition was observed divided by the number
of times action a was taken in state s. If D contains no examples
of action a being taken in state s, then we assume
that taking action a in state s always causes a transition to
the terminal absorbing state.
'''
# frames = np.array([x['frames'] for x in dataset])
# transitions = np.vstack([ frames[:,:-1].reshape(-1), #np.array([x['x'] for x in dataset]).reshape(-1,1).T ,
# np.array([x['a'] for x in dataset]).reshape(-1,1).T ,
# frames[:,1:].reshape(-1), #np.array([x['x_prime'] for x in dataset]).reshape(-1,1).T
# # np.array([x['done'] for x in dataset]).reshape(-1,1).T
# ]).T
frames = dataset.frames()
transitions = np.vstack([ frames[:,:-1].reshape(-1), #np.array([x['x'] for x in dataset]).reshape(-1,1).T ,
dataset.actions(False) ,
frames[:,1:].reshape(-1), #np.array([x['x_prime'] for x in dataset]).reshape(-1,1).T
# np.array([x['done'] for x in dataset]).reshape(-1,1).T
]).T
unique, idx, count = np.unique(transitions, return_index=True, return_counts=True, axis=0)
# partial_transitions = np.vstack([ frames[:,:-1].reshape(-1), #np.array([x['x'] for x in dataset]).reshape(-1,1).T ,
# np.array([x['a'] for x in dataset]).reshape(-1,1).T ,
# ]).T
partial_transitions = np.vstack([ frames[:,:-1].reshape(-1), #np.array([x['x'] for x in dataset]).reshape(-1,1).T ,
dataset.actions(False) ,
]).T
unique_a_given_x, idx_a_given_x, count_a_given_x = np.unique(partial_transitions, return_index=True, return_counts=True, axis=0)
# key=(state, action). value= number of times a was taking in state
all_counts_a_given_x = {tuple(key):value for key,value in zip(unique_a_given_x,count_a_given_x)}
prob = {}
for idx,row in enumerate(unique):
if tuple(row[:-1]) in prob:
prob[tuple(row[:-1])][row[-1]] = count[idx] / all_counts_a_given_x[(row[0],row[1])]
else:
prob[tuple(row[:-1])] = {}
prob[tuple(row[:-1])][row[-1]] = count[idx] / all_counts_a_given_x[(row[0],row[1])]
# if self.absorbing is not None:
# for act in np.arange(self.action_space_dim):
# prob[tuple([self.absorbing[0], act])] = {self.absorbing[0]:1.}
self.P = prob
# all_transitions = np.vstack([ frames[:,:-1].reshape(-1), #np.array([x['x'] for x in dataset]).reshape(-1,1).T ,
# np.array([x['a'] for x in dataset]).reshape(-1,1).T ,
# frames[:,1:].reshape(-1), #np.array([x['x_prime'] for x in dataset]).reshape(-1,1).T ,
# np.array([x['done'] for x in dataset]).reshape(-1,1).T ,
# ]).T
all_transitions = np.vstack([ frames[:,:-1].reshape(-1), #np.array([x['x'] for x in dataset]).reshape(-1,1).T ,
dataset.actions(False) ,
frames[:,1:].reshape(-1), #np.array([x['x_prime'] for x in dataset]).reshape(-1,1).T ,
dataset.dones(False) ,
]).T
unique, idx, count = np.unique(all_transitions, return_index=True, return_counts=True, axis=0)
unique_a_given_x, idx_a_given_x, count_a_given_x = np.unique(transitions, return_index=True, return_counts=True, axis=0)
# key=(state, action). value= number of times a was taking in state
all_counts_a_given_x = {tuple(key):value for key,value in zip(unique_a_given_x,count_a_given_x)}
done = {}
for idx,row in enumerate(unique):
if tuple(row[:-1]) in done:
done[tuple(row[:-1])][row[-1]] = count[idx] / all_counts_a_given_x[tuple(row[:-1])]
else:
done[tuple(row[:-1])] = {}
done[tuple(row[:-1])][row[-1]] = count[idx] / all_counts_a_given_x[tuple(row[:-1])]
self.D = done
# self.terminal_transitions = {tuple([x,a,x_prime]):1 for x,a,x_prime in all_transitions[all_transitions[:,-1] == True][:,:-1]}
# Actually fitting R, not Q_k
# self.Q_k = self.model #init_Q(model_type=self.model_type)
# X_a = np.array(zip(dataset['x'],dataset['a']))#dataset['state_action']
# x_prime = dataset['x_prime']
# index_of_skim = self.skim(X_a, x_prime)
# self.fit(X_a[index_of_skim], dataset['cost'][index_of_skim], batch_size=len(index_of_skim), verbose=0, epochs=1000)
# self.reward = self
# self.P = prob
if self.override_done:
# transitions = np.vstack([ frames[:,:-1].reshape(-1), #np.array([x['x'] for x in dataset]).reshape(-1,1).T ,
# np.array([x['a'] for x in dataset]).reshape(-1,1).T ,
# np.array([range(len(x['x'])) for x in dataset]).reshape(-1,1).T,
# np.array([x['r'] for x in dataset]).reshape(-1,1).T ,
# ]).T
# partial_transitions = np.vstack([ frames[:,:-1].reshape(-1), #np.array([x['x'] for x in dataset]).reshape(-1,1).T ,
# np.array([x['a'] for x in dataset]).reshape(-1,1).T ,
# np.array([range(len(x['x'])) for x in dataset]).reshape(-1,1).T,
# ]).T
transitions = np.vstack([ frames[:,:-1].reshape(-1), #np.array([x['x'] for x in dataset]).reshape(-1,1).T ,
dataset.actions(False) ,
dataset.ts(False),
dataset.rewards(False) ,
]).T
partial_transitions = np.vstack([ frames[:,:-1].reshape(-1), #np.array([x['x'] for x in dataset]).reshape(-1,1).T ,
dataset.actions(False) ,
dataset.ts(False),
]).T
else:
# transitions = np.vstack([ frames[:,:-1].reshape(-1), #np.array([x['x'] for x in dataset]).reshape(-1,1).T ,
# np.array([x['a'] for x in dataset]).reshape(-1,1).T ,
# np.array([x['r'] for x in dataset]).reshape(-1,1).T ,
# ]).T
# partial_transitions = np.vstack([ frames[:,:-1].reshape(-1), #np.array([x['x'] for x in dataset]).reshape(-1,1).T ,
# np.array([x['a'] for x in dataset]).reshape(-1,1).T ,
# ]).T
transitions = np.vstack([ frames[:,:-1].reshape(-1), #np.array([x['x'] for x in dataset]).reshape(-1,1).T ,
dataset.actions(False) ,
dataset.rewards(False) ,
]).T
partial_transitions = np.vstack([ frames[:,:-1].reshape(-1), #np.array([x['x'] for x in dataset]).reshape(-1,1).T ,
dataset.actions(False) ,
]).T
unique, idxs, counts = np.unique(transitions, return_index=True, return_counts=True, axis=0)
unique_a_given_x, idx_a_given_x, count_a_given_x = np.unique(partial_transitions, return_index=True, return_counts=True, axis=0)
# key=(state, action). value= number of times a was taking in state
all_counts_a_given_x = {tuple(key):value for key,value in zip(unique_a_given_x,count_a_given_x)}
rew = {}
for idx,row in enumerate(unique):
if tuple(row[:-1]) in rew:
rew[tuple(row[:-1])][row[-1]] = counts[idx] / all_counts_a_given_x[tuple(row[:-1])]
else:
rew[tuple(row[:-1])] = {}
rew[tuple(row[:-1])][row[-1]] = counts[idx] / all_counts_a_given_x[tuple(row[:-1])]
self.R = rew
self.fitted = 'tabular'
def estimate_R(self, x, a, t):
# Exact R
# self.R = {(0, 0): {-1: .06, 0: .5, 1: .44}, (0, 1): {-1: .06, 0: .5, 1: .44}}
#Approximated rewards
if len(list(self.R)[0]) == 3:
key = tuple([x,a,t])
else:
key = tuple([x,a])
if key in self.R:
try:
reward = np.random.choice(list(self.R[key]), p=list(self.R[key].values()))
except:
import pdb; pdb.set_trace()
else:
reward = 0
return reward
def transition_tabular(self, x, a):
# Exact MDP dynamics
# self.P = {(0, 0): {0: 0.5, 1: 0.5}, (0, 1): {0: 0.5, 1: .5}}
#Approximated dynamics
if tuple([x,a]) in self.P:
try:
state = np.random.choice(list(self.P[(x,a)]), p=list(self.P[(x,a)].values()))
if self.override_done:
done = False
else:
done = np.random.choice(list(self.D[(x,a,state)]),
p=list(self.D[(x,a,state)].values()))
except:
import pdb; pdb.set_trace()
else:
state = None
done = True
return state, done
def Q_tabular(self, policy, x, gamma, t=0):
all_Qs = []
for t, X in enumerate(x):
Qs = []
for a in range(self.n_actions):
state = X[0][0]
if isinstance(a, type(np.array([]))) or isinstance(a, list):
assert len(a) == 1
a = a[0]
done = False
costs = []
trajectory_length = t
# Q
while not done:
new_state, done = self.transition_tabular(state, a)
costs.append( self.estimate_R(state, a, trajectory_length) )
# if (tuple([state,a,new_state]) in self.terminal_transitions):
# done = True
trajectory_length += 1
if self.max_traj_length is not None:
if trajectory_length >= self.max_traj_length:
done = True
if not done:
state = new_state
a = policy([state])[0]
Qs.append(self.discounted_sum(costs, gamma))
all_Qs.append(Qs)
return np.array(all_Qs)
@staticmethod
def discounted_sum(costs, discount):
'''
Calculate discounted sum of costs
'''
y = signal.lfilter([1], [1, -discount], x=costs[::-1])
return y[::-1][0]
| 21,915 | 41.55534 | 136 | py |
SOPE | SOPE-master/ope/algos/event_is.py | # Interpolation via n-step interpolation implemented.
import numpy as np
import tensorflow as tf
from time import sleep
import sys
import os
from tqdm import tqdm
from tensorflow.python import debug as tf_debug
import json
from scipy.optimize import linprog
from scipy.optimize import minimize
import quadprog
import keras
from keras.layers import Dense, Conv2D, Flatten, MaxPool2D, concatenate, UpSampling2D, Reshape, Lambda, Conv2DTranspose
from keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
from keras.optimizers import Adam
from keras import backend as K
from tqdm import tqdm
from ope.utls.thread_safe import threadsafe_generator
from keras import regularizers
# Hyper parameter
#Learning_rate = 1e-3
#initial_stddev = 0.5
#Training Parameter
training_batch_size = 1024 #1024 * 2**2
training_maximum_iteration = 40001
TEST_NUM = 0
NUMBER_OF_REPEATS = 1
from ope.utils import keyboard
class EventIS(object):
def __init__(self, data, w_hidden, Learning_rate, reg_weight, gamma, discrete, modeltype, interp_type="n-step", env=None, processor=None, weighted=True):
"""
Default interpolation is n-step with n-set to 0. This gives us standard PDIS.
"""
self.data = data
self.modeltype = modeltype
self.gamma = gamma
self.is_discrete = discrete
self.processor = processor
self.interp_type = interp_type
self.weighted = weighted
self.lr = Learning_rate
if self.is_discrete:
self.obs_dim = env.num_states() if env is not None else self.data.num_states()
self.den_discrete = Density_Ratio_discounted(self.obs_dim, gamma)
else:
# self.g = tf.Graph()
# with self.g.as_default():
# with tf.variable_scope('infhorizon', reuse=False):
# self._build_graph(w_hidden, Learning_rate, reg_weight)
# self._init_session()
pass
def build_model(self, input_size, scope, action_space_dim=3, modeltype='conv'):
isStart = keras.layers.Input(shape=(1,), name='dummy')
state = keras.layers.Input(shape=input_size, name='state')
next_state = keras.layers.Input(shape=input_size, name='next_state')
median_dist = keras.layers.Input(shape=(1,), name='med_dist')
policy_ratio = keras.layers.Input(shape=(1,), name='policy_ratio')
if modeltype == 'conv':
def init(): return keras.initializers.RandomNormal(mean=0.0, stddev=.003, seed=np.random.randint(2**32))
conv1 = Conv2D(8, (7,7), strides=(3,3), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init())
pool1 = MaxPool2D(data_format='channels_first')
conv2 = Conv2D(16, (3,3), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init())
pool2 = MaxPool2D(data_format='channels_first')
flat1 = Flatten(name='flattened')
out = Dense(1, activation='linear',kernel_initializer=init(), bias_initializer=init())
output = Lambda(lambda x: tf.exp(tf.clip_by_value(x,-10,10)))
w = output(out(flat1(pool2(conv2(pool1(conv1(state)))))))
w_next = output(out(flat1(pool2(conv2(pool1(conv1(next_state)))))))
trainable_model = keras.models.Model(inputs=[state,next_state,policy_ratio,isStart,median_dist], outputs=[w])
w_model = keras.models.Model(inputs=[state], outputs=w)
elif modeltype == 'conv1':
def init(): return keras.initializers.RandomNormal(mean=0.0, stddev=.003, seed=np.random.randint(2**32))
conv1 = Conv2D(8, (2,2), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init())
pool1 = MaxPool2D(data_format='channels_first')
conv2 = Conv2D(16, (2,2), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init())
pool2 = MaxPool2D(data_format='channels_first')
flat1 = Flatten(name='flattened')
out = Dense(1, activation='linear',kernel_initializer=init(), bias_initializer=init())
output = Lambda(lambda x: tf.exp(tf.clip_by_value(x,-10,10)))
w = output(out(flat1(pool2(conv2(pool1(conv1(state)))))))
w_next = output(out(flat1(pool2(conv2(pool1(conv1(next_state)))))))
trainable_model = keras.models.Model(inputs=[state,next_state,policy_ratio,isStart,median_dist], outputs=[w])
w_model = keras.models.Model(inputs=[state], outputs=w)
elif modeltype == 'linear':
def init(): return keras.initializers.RandomNormal(mean=0.0, stddev=.003, seed=np.random.randint(2**32))
dense1 = Dense(1, activation='linear', name='out',kernel_initializer=init(), bias_initializer=keras.initializers.Zeros())
output = Lambda(lambda x: tf.exp(tf.clip_by_value(x,-10,10)))
w = output(dense1(state))
w_next = output(dense1(next_state))
trainable_model = keras.models.Model(inputs=[state,next_state,policy_ratio,isStart,median_dist], outputs=[w])
w_model = keras.models.Model(inputs=[state], outputs=w)
else:
def init(): return keras.initializers.RandomNormal(mean=0.0, stddev=.003, seed=np.random.randint(2**32))
dense1 = Dense(16, activation='relu',kernel_initializer=init(), bias_initializer=keras.initializers.Zeros())
dense2 = Dense(8, activation='relu',kernel_initializer=init(), bias_initializer=keras.initializers.Zeros())
dense3 = Dense(1, activation='linear', name='out',kernel_initializer=init(), bias_initializer=keras.initializers.Zeros())
output = Lambda(lambda x: tf.exp(tf.clip_by_value(x,-10,10)))
w = output(dense3(dense2(dense1(state))))
w_next = output(dense3(dense2(dense1(next_state))))
trainable_model = keras.models.Model(inputs=[state,next_state,policy_ratio,isStart,median_dist], outputs=[w])
w_model = keras.models.Model(inputs=[state], outputs=w)
rmsprop = keras.optimizers.RMSprop(lr=self.lr, rho=0.95, epsilon=1e-08, decay=1e-3)#, clipnorm=1.)
adam = keras.optimizers.Adam(lr=self.lr)
trainable_model.add_loss(self.IH_loss(next_state,w,w_next,policy_ratio,isStart, median_dist, self.modeltype))
trainable_model.compile(loss=None, optimizer=rmsprop, metrics=['accuracy'])
# trainable_model.compile(loss=None, optimizer=adam, metrics=['accuracy'])
return trainable_model, w_model
@staticmethod
def IH_loss(next_state, w, w_next,policy_ratio,isStart, med_dist, modeltype):
# change from tf to K.backend?
norm_w = tf.reduce_mean(w)
# calculate loss function
x = (1-isStart) * w * policy_ratio + isStart * norm_w - w_next
x = tf.reshape(x,[-1,1])
diff_xx = tf.expand_dims(next_state, 0) - tf.expand_dims(next_state, 1)
if modeltype in ['conv', 'conv1']:
K_xx = tf.exp(-tf.reduce_sum(tf.square(diff_xx),axis=[-1, -2, -3])/(2.0*med_dist*med_dist))#*med_dist))
else:
K_xx = tf.exp(-tf.reduce_sum(tf.square(diff_xx),axis=[-1])/(2.0*med_dist*med_dist))#*med_dist))
loss_xx = tf.matmul(tf.matmul(tf.transpose(x),K_xx),x)#/(n_x*n_x)
loss = tf.squeeze(loss_xx)/(norm_w*norm_w)
return tf.reduce_mean(loss)
def run_NN(self, env, max_epochs, batch_size, epsilon=0.001, modeltype_overwrite =None):
self.dim_of_actions = env.n_actions
self.Q_k = None
# earlyStopping = EarlyStopping(monitor='val_loss', min_delta=1e-4, patience=10, verbose=1, mode='min', restore_best_weights=True)
# reduce_lr_loss = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=7, verbose=1, min_delta=1e-4, mode='min')
self.more_callbacks = [] #[earlyStopping, reduce_lr_loss]
im = self.data.states()[0]
if self.processor: im = self.processor(im)
if self.modeltype in ['conv', 'conv1']:
trainable_model, state_to_w = self.build_model(im.shape[1:], 'w', modeltype=modeltype_overwrite if modeltype_overwrite is not None else self.modeltype)
state_to_w.predict([im])
self.state_to_w = state_to_w
self.trainable_model = trainable_model
else:
trainable_model, state_to_w = self.build_model((np.prod(im.shape[1:]),), 'w', modeltype=self.modeltype)
state_to_w.predict([[im[0].reshape(-1)]])
self.state_to_w = state_to_w
self.trainable_model = trainable_model
values = []
losses = []
for k in tqdm(range(1)):
dataset_length = self.data.num_tuples()
perm = np.random.permutation(range(dataset_length))
eighty_percent_of_set = int(0.8*len(perm))
training_idxs = perm[:eighty_percent_of_set]
validation_idxs = perm[eighty_percent_of_set:]
training_steps_per_epoch = max(500, int(.03 * np.ceil(len(training_idxs)/float(batch_size))))
# training_steps_per_epoch = 1 #int(1. * np.ceil(len(training_idxs)/float(batch_size)))
validation_steps_per_epoch = max(200, int(np.ceil(len(validation_idxs)/float(batch_size))))
train_gen = self.generator(env, training_idxs, fixed_permutation=True, batch_size=batch_size)
val_gen = self.generator(env, validation_idxs, fixed_permutation=True, batch_size=batch_size)
M = 5
hist = self.trainable_model.fit_generator(train_gen,
steps_per_epoch=training_steps_per_epoch,
validation_data=val_gen,
validation_steps=validation_steps_per_epoch,
epochs=max_epochs,
max_queue_size=50,
workers=1,
use_multiprocessing=False,
verbose=1,
callbacks = self.more_callbacks)
return state_to_w
# return np.mean(values[-10:]), self.Q_k, self.Q_k_all
def euclidean(self, X, Y):
distance = np.zeros((len(X), len(Y)))
for row,x in enumerate(X):
for col,y in enumerate(Y):
y_row,y_col = np.unravel_index(np.argmin(y.reshape(-1), y.shape))
x_row,x_col = np.unravel_index(np.argmin(y.reshape(-1), y.shape))
distance = np.sqrt((x_row-y_row)**2 + (x_col+y_col)**2)
return distance
@threadsafe_generator
def generator(self, env, all_idxs, fixed_permutation=False, batch_size = 64):
data_length = len(all_idxs)
steps = int(np.ceil(data_length/float(batch_size)))
n = len(self.data)
T = max(self.data.lengths())
n_dim = self.data.n_dim
n_actions = self.data.n_actions
S = np.hstack([self.data.states()[:,[0]], self.data.states()])
SN = np.hstack([self.data.states()[:,[0]], self.data.next_states()])
PI0 = np.hstack([self.data.base_propensity()[:,[0]], self.data.base_propensity()])
PI1 = np.hstack([self.data.target_propensity()[:,[0]], self.data.target_propensity()])
ACTS = np.hstack([np.zeros_like(self.data.actions()[:,[0]]), self.data.actions()])
pi0 = []
pi1 = []
for i in range(len(ACTS)):
pi0_ = []
pi1_ = []
for j in range(len(ACTS[1])):
a = ACTS[i,j]
pi0_.append(PI0[i,j,a])
pi1_.append(PI1[i,j,a])
pi0.append(pi0_)
pi1.append(pi1_)
PI0 = np.array(pi0)
PI1 = np.array(pi1)
REW = np.hstack([np.zeros_like(self.data.rewards()[:,[0]]), self.data.rewards()])
ISSTART = np.zeros_like(REW)
ISSTART[:,0] = 1.
PROBS = np.repeat(np.atleast_2d(self.gamma**np.arange(-1,REW.shape[1]-1)), REW.shape[0], axis=0).reshape(REW.shape)
S = np.vstack(S)
SN = np.vstack(SN)
PI1 = PI1.reshape(-1)
PI0 = PI0.reshape(-1)
ISSTART = ISSTART.reshape(-1)
PROBS = PROBS.reshape(-1)
PROBS /= sum(PROBS)
N = S.shape[0]
subsamples = np.random.choice(N, len(S))
bs = batch_size
num_batches = max(len(subsamples) // bs,1)
med_dist = []
for batch_num in tqdm(range(num_batches)):
low_ = batch_num * bs
high_ = (batch_num + 1) * bs
sub = subsamples[low_:high_]
if self.modeltype in ['conv']:
s = self.processor(S[sub])
else:
s = S[sub].reshape(len(sub),-1)[...,None,None]
med_dist.append(np.sum(np.square(s[None, :, :] - s[:, None, :]), axis = tuple([-3,-2,-1])))
med_dist = np.sqrt(np.median(np.array(med_dist).reshape(-1)[np.array(med_dist).reshape(-1) > 0]))
while True:
# perm = np.random.permutation(all_idxs)
for batch in np.arange(steps):
# batch_idxs = perm[(batch*batch_size):((batch+1)*batch_size)]
batch_idxs = np.random.choice(S.shape[0], batch_size, p=PROBS)
if self.modeltype in ['conv', 'conv1']:
state = self.processor(S[batch_idxs])
next_state = self.processor(SN[batch_idxs])
else:
state = S[batch_idxs].reshape(len(batch_idxs),-1)#[...,None,None]
next_state = SN[batch_idxs].reshape(len(batch_idxs),-1)#[...,None,None]
policy_ratio = PI1[batch_idxs] / PI0[batch_idxs]
isStart = ISSTART[batch_idxs]
median_dist = np.repeat(med_dist, batch_size)
yield ([state,next_state,policy_ratio,isStart,median_dist], [])
def estimate_density_ratios(self, env, max_epochs, matrix_size):
dataset = self.data
if self.is_discrete:
S = np.squeeze(dataset.states())
SN = np.squeeze(dataset.next_states())
PI0 = dataset.base_propensity()
PI1 = dataset.target_propensity()
REW = dataset.rewards()
ACTS = dataset.actions()
self.den_discrete.reset()
for episode in range(len(S)):
discounted_t = 1.0
initial_state = S[episode][0]
for (s,a,sn,r,pi1,pi0) in zip(S[episode],ACTS[episode],SN[episode], REW[episode], PI1[episode], PI0[episode]):
discounted_t *= self.gamma
policy_ratio = (pi1/pi0)[a]
self.den_discrete.feed_data(s, sn, initial_state, policy_ratio, discounted_t)
self.den_discrete.feed_data(-1, initial_state, initial_state, 1, 1-discounted_t)
x, w = self.den_discrete.density_ratio_estimate()
return w[S]
else:
batch_size = matrix_size
# Here Linear = linear NN
self.state_to_w = self.run_NN(env, max_epochs, batch_size, epsilon=0.001)
S = np.vstack(self.data.states())
ACTS = self.data.actions()
REW = self.data.rewards().reshape(-1)
PI0 = self.probs_per_action(self.data.base_propensity(), ACTS).reshape(-1)
PI1 = self.probs_per_action(self.data.target_propensity(), ACTS).reshape(-1)
predict_batch_size = max(128, batch_size)
steps = int(np.ceil(S.shape[0]/float(predict_batch_size)))
densities = []
for batch in np.arange(steps):
batch_idxs = np.arange(S.shape[0])[(batch*predict_batch_size):((batch+1)*predict_batch_size)]
if self.modeltype in ['conv', 'conv1']:
s = self.processor(S[batch_idxs])
densities.append(self.state_to_w.predict(s))
else:
s = S[batch_idxs]
s = s.reshape(s.shape[0], -1)
densities.append(self.state_to_w.predict(s))
densities = np.vstack(densities).reshape(-1)
return densities.reshape(self.data.states().shape)
def get_probs_per_action(self, P, A):
pi = []
for i in range(len(A)):
pi_ = []
for j in range(len(A[1])):
pi_.append(P[i,j,A[i,j]])
pi.append(pi_)
return np.array(pi)
def evaluate(self, env, max_epochs, matrix_size, nstep_int=1, nstep_custom_ns=None):
dataset = self.data
all_event_estimates = {}
if self.is_discrete:
REW = dataset.rewards()
ACTS = dataset.actions()
density_ratios = self.estimate_density_ratios(env, max_epochs, matrix_size)
PI0 = self.get_probs_per_action(dataset.base_propensity(), ACTS)
PI1 = self.get_probs_per_action(dataset.target_propensity(), ACTS)
is_weights = (PI1 / PI0)
DISC_FACTORS = np.repeat(np.atleast_2d(self.gamma**np.arange(REW.shape[1])),
REW.shape[0], axis=0).reshape(REW.shape)
if (nstep_custom_ns is not None):
for interp_param in nstep_custom_ns:
all_event_estimates[interp_param] = self.off_policy_estimator_event(self.interp_type, interp_param, REW, DISC_FACTORS, is_weights, density_ratios, weighted=self.weighted)
else:
for interp_param in range(0, dataset.states().shape[1]+1, nstep_int):
all_event_estimates[interp_param] = self.off_policy_estimator_event(self.interp_type, interp_param, REW, DISC_FACTORS, is_weights, density_ratios, weighted=self.weighted)
return all_event_estimates
else:
batch_size = matrix_size
# Here Linear = linear NN
self.state_to_w = self.run_NN(env, max_epochs, batch_size, epsilon=0.001)
S = self.data.states() # [num_traj, horizon, ...]
ACTS = self.data.actions() #np.hstack([np.zeros_like(self.data.actions()[:,[0]]), self.data.actions()])
PI0 = self.get_probs_per_action(self.data.base_propensity(), ACTS)
PI1 = self.get_probs_per_action(self.data.target_propensity(), ACTS)
REW = self.data.rewards() #np.hstack([np.zeros_like(self.data.rewards()[:,[0]]), self.data.rewards()])
DISC_FACTORS = np.repeat(np.atleast_2d(self.gamma**np.arange(REW.shape[1])), REW.shape[0], axis=0).reshape(REW.shape)
(num_traj, horizon) = REW.shape
S = np.vstack(S)
is_weights = (PI1 / PI0)
predict_batch_size = max(128, batch_size)
steps = int(np.ceil(S.shape[0]/float(predict_batch_size)))
densities = []
for batch in np.arange(steps):
batch_idxs = np.arange(S.shape[0])[(batch*predict_batch_size):((batch+1)*predict_batch_size)]
if self.modeltype in ['conv', 'conv1']:
s = self.processor(S[batch_idxs])
densities.append(self.state_to_w.predict(s))
else:
s = S[batch_idxs]
s = s.reshape(s.shape[0], -1)
densities.append(self.state_to_w.predict(s))
densities = np.vstack(densities).reshape(-1).reshape(num_traj, horizon)
if (nstep_custom_ns is not None):
for interp_param in nstep_custom_ns:
all_event_estimates[interp_param] = self.off_policy_estimator_event(
self.interp_type, interp_param, REW, DISC_FACTORS, is_weights,
densities, weighted=self.weighted)
else:
for interp_param in range(0, dataset.states().shape[1]+1, nstep_int):
all_event_estimates[interp_param] = self.off_policy_estimator_event(
self.interp_type, interp_param, REW, DISC_FACTORS, is_weights, densities,
weighted=self.weighted)
return all_event_estimates
@staticmethod
def off_policy_estimator_event(interp_type, interp_param, rew, disc_factor, is_weights, den_ratio, weighted):
(num_traj, horizon) = rew.shape
if (interp_type == "n-step"):
interp_n = interp_param
event_est = 0
for t in range(horizon):
prod_is_weights = np.prod(is_weights[:, max(t-interp_n, 0):t+1], axis=1)
drop_den_ratio = den_ratio[:, t-interp_n] if t >= interp_n else np.ones(num_traj)
r_t = rew[:, t]
t_sum = np.sum(disc_factor[:,t] * drop_den_ratio * prod_is_weights * rew[:,t])
t_weight = np.sum(drop_den_ratio * prod_is_weights)
event_est += t_sum / t_weight if weighted else t_sum / num_traj
else:
raise ValueError("Please specify valid interpolation type")
return event_est
@staticmethod
def off_policy_estimator_density_ratio(rew, disc_factor, ratio, den_r, weighted):
(num_traj, horizon) = rew.shape
ih_est = np.sum(disc_factor * den_r * ratio * rew)
if weighted:
ih_est /= np.sum(disc_factor * den_r * ratio)
else:
ih_est /= num_traj
return ih_est
def get_model_params(self):
# get trainable params.
model_names = []
model_params = []
model_shapes = []
with self.g.as_default():
t_vars = tf.trainable_variables()
for var in t_vars:
if var.name.startswith('infhorizon'):
param_name = var.name
p = self.sess.run(var)
model_names.append(param_name)
params = np.round(p*10000).astype(np.int).tolist()
model_params.append(params)
model_shapes.append(p.shape)
return model_params, model_shapes, model_names
def set_model_params(self, params):
with self.g.as_default():
t_vars = tf.trainable_variables()
idx = 0
for var in t_vars:
if var.name.startswith('infhorizon'):
pshape = tuple(var.get_shape().as_list())
p = np.array(params[idx])
assert pshape == p.shape, "inconsistent shape"
assign_op, pl = self.assign_ops[var]
self.sess.run(assign_op, feed_dict={pl.name: p/10000.})
idx += 1
def load_json(self, jsonfile='infhorizon.json'):
with open(jsonfile, 'r') as f:
params = json.load(f)
self.set_model_params(params)
def save_json(self, jsonfile='infhorizon.json'):
model_params, model_shapes, model_names = self.get_model_params()
qparams = []
for p in model_params:
qparams.append(p)
with open(jsonfile, 'wt') as outfile:
json.dump(qparams, outfile, sort_keys=True, indent=0, separators=(',', ': '))
def linear_solver(n, M):
M -= np.amin(M) # Let zero sum game at least with nonnegative payoff
c = np.ones((n))
b = np.ones((n))
res = linprog(-c, A_ub = M.T, b_ub = b)
w = res.x
return w/np.sum(w)
def quadratic_solver(n, M, regularizer):
qp_G = np.matmul(M, M.T)
qp_G += regularizer * np.eye(n)
qp_a = np.zeros(n, dtype = np.float64)
qp_C = np.zeros((n,n+1), dtype = np.float64)
for i in range(n):
qp_C[i,0] = 1.0
qp_C[i,i+1] = 1.0
qp_b = np.zeros(n+1, dtype = np.float64)
qp_b[0] = 1.0
meq = 1
res = quadprog.solve_qp(qp_G, qp_a, qp_C, qp_b, meq)
w = res[0]
return w
class Density_Ratio_discounted(object):
def __init__(self, num_state, gamma):
self.num_state = num_state
self.Ghat = np.zeros([num_state, num_state], dtype = np.float64)
self.Nstate = np.zeros([num_state, 1], dtype = np.float64)
self.initial_b = np.zeros([num_state], dtype = np.float64)
self.gamma = gamma
def reset(self):
num_state = self.num_state
self.Ghat = np.zeros([num_state, num_state], dtype = np.float64)
self.Nstate = np.zeros([num_state, 1], dtype = np.float64)
def feed_data(self, cur, next, initial, policy_ratio, discounted_t):
if cur == -1:
self.Ghat[next, next] -= discounted_t
else:
self.Ghat[cur, next] += policy_ratio * discounted_t
self.Ghat[cur, initial] += (1-self.gamma)/self.gamma * discounted_t
self.Ghat[next, next] -= discounted_t
self.Nstate[cur] += discounted_t
def density_ratio_estimate(self, regularizer = 0.001):
Frequency = self.Nstate.reshape(-1)
tvalid = np.where(Frequency >= 1e-20)
G = np.zeros_like(self.Ghat)
Frequency = Frequency/np.sum(Frequency)
G[tvalid] = self.Ghat[tvalid]/(Frequency[:,None])[tvalid]
n = self.num_state
# x is estimated stationary distribution of pi
# Frequency is estimates stationary distribution of pi_0
x = quadratic_solver(n, G/50.0, regularizer)
w = np.zeros(self.num_state)
w[tvalid] = x[tvalid]/Frequency[tvalid]
return x, w
| 25,476 | 43.462478 | 188 | py |
SOPE | SOPE-master/ope/algos/more_robust_doubly_robust.py | import sys
import numpy as np
import pandas as pd
from copy import deepcopy
from keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
import keras
from keras.models import Sequential
from keras.layers import Dense, Conv2D, Flatten, MaxPool2D, concatenate, UpSampling2D, Reshape, Lambda
from keras.optimizers import Adam
from keras import backend as K
import tensorflow as tf
from tqdm import tqdm
from ope.utls.thread_safe import threadsafe_generator
from keras import regularizers
from sklearn.linear_model import LinearRegression, LogisticRegression
class MRDR(object):
def __init__(self, data, gamma, frameskip=2, frameheight=2, modeltype = 'conv', processor=None):
self.data = data
self.gamma = gamma
self.frameskip = frameskip
self.frameheight = frameheight
self.modeltype = modeltype
self.processor = processor
def q_beta(self):
return tf.matmul(tf.matrix_diag(self.pi1), tf.expand_dims(self.out,2)) - tf.expand_dims(self.rew, 2)
def Q_val(self):
with tf.variable_scope('w', reuse = tf.AUTO_REUSE):
# h = tf.layers.conv2d(self.s, 32, 4, data_format='channels_first', strides=2, activation=tf.nn.relu, name="enc_conv1")
# h = tf.layers.conv2d(h, 64, 4, data_format='channels_first', strides=2, activation=tf.nn.relu, name="enc_conv2")
# h = tf.layers.conv2d(h, 128, 4, data_format='channels_first', strides=2, activation=tf.nn.relu, name="enc_conv3")
# h = tf.layers.conv2d(h, 256, 4, data_format='channels_first', strides=2, activation=tf.nn.relu, name="enc_conv4")
# h = tf.reshape(h, [-1, 3*5*256])
# # Some dense layers
s = tf.layers.flatten(self.s)
dense1 = tf.layers.dense(s, 16, activation=tf.nn.relu, name="dense1", kernel_regularizer = tf.contrib.layers.l2_regularizer(1.), bias_regularizer = tf.contrib.layers.l2_regularizer(1.))
dense2 = tf.layers.dense(dense1, 8, activation=tf.nn.relu, name="dense2", kernel_regularizer = tf.contrib.layers.l2_regularizer(1.), bias_regularizer = tf.contrib.layers.l2_regularizer(1.))
out = tf.layers.dense(dense2, self.action_dim, name="Q")
return out
def build_model_(self, input_size, scope, action_space_dim=3, modeltype='conv'):
# place holder
self.action_dim = action_space_dim
# tio2 = tf.placeholder(tf.float32, [None], name='policy_ratio2')
self.s = tf.placeholder(tf.float32, [None] + list(input_size), name='state')
# self.gam = tf.placeholder(tf.float32, [None] , name='gamma_sq')
# self.omega_cumul = tf.placeholder(tf.float32, [None] , name='cumulative_omega')
# self.omega = tf.placeholder(tf.float32, [None] , name='current_omega')
self.factor = tf.placeholder(tf.float32, [None] , name='current_omega')
self.rew = tf.placeholder(tf.float32, [None] + [self.action_dim], name='disc_future_rew')
self.pi0 = tf.placeholder(tf.float32, [None] + [self.action_dim], name='pi_b')
self.pi1 = tf.placeholder(tf.float32, [None] + [self.action_dim], name='pi_e')
# self.factor = self.gam * (self.omega_cumul**2) * self.omega
self.Omega = tf.matrix_diag(1/self.pi0)
self.Omega = self.Omega - tf.ones_like(self.Omega)
self.out = self.Q_val()
self.q = self.q_beta()
self.loss_pre_reduce = tf.matmul(tf.matmul(tf.transpose(self.q, [0,2,1]) , self.Omega), self.q)
self.loss_pre_reduce_w_factor = self.factor * tf.squeeze(self.loss_pre_reduce)
self.loss = tf.reduce_sum(self.loss_pre_reduce_w_factor)
self.reg_loss = tf.reduce_sum(tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES, 'mrdr'))
LR = .001
reg_weight = 0.
self.train_op = tf.train.AdamOptimizer(LR).minimize(self.loss + reg_weight * self.reg_loss)
# initialize vars
self.init = tf.global_variables_initializer()
# Create assign opsfor VAE
t_vars = tf.trainable_variables()
self.assign_ops = {}
for var in t_vars:
if var.name.startswith('mrdr'):
pshape = var.get_shape()
pl = tf.placeholder(tf.float32, pshape, var.name[:-2]+'_placeholder')
assign_op = var.assign(pl)
self.assign_ops[var] = (assign_op, pl)
def _init_session(self):
"""Launch TensorFlow session and initialize variables"""
self.sess = tf.Session(graph=self.g)
self.sess.run(self.init)
def build_model(self, input_size, scope, action_space_dim=3, modeltype='conv'):
inp = keras.layers.Input(input_size, name='frames')
actions = keras.layers.Input((action_space_dim,), name='mask')
weights = keras.layers.Input((1,), name='weights')
rew = keras.layers.Input((action_space_dim,), name='rewards')
pib = keras.layers.Input((action_space_dim,), name='pi_b')
pie = keras.layers.Input((action_space_dim,), name='pi_e')
def init(): return keras.initializers.TruncatedNormal(mean=0.0, stddev=0.001, seed=np.random.randint(2**32))
if modeltype == 'conv':
conv1 = Conv2D(8, (7,7), strides=(3,3), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(inp)
pool1 = MaxPool2D(data_format='channels_first')(conv1)
conv2 = Conv2D(16, (3,3), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(pool1)
pool2 = MaxPool2D(data_format='channels_first')(conv2)
flat1 = Flatten(name='flattened')(pool2)
out = Dense(256, activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(flat1)
elif modeltype == 'conv1':
def init(): return keras.initializers.TruncatedNormal(mean=0.0, stddev=0.001, seed=np.random.randint(2**32))
conv1 = Conv2D(16, (2,2), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(inp)
# pool1 = MaxPool2D(data_format='channels_first')(conv1)
# conv2 = Conv2D(16, (2,2), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(pool1)
# pool2 = MaxPool2D(data_format='channels_first')(conv2)
flat1 = Flatten(name='flattened')(conv1)
out = Dense(8, activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(flat1)
out = Dense(8, activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(out)
else:
def init(): return keras.initializers.TruncatedNormal(mean=0.0, stddev=.001, seed=np.random.randint(2**32))
flat = Flatten()(inp)
dense1 = Dense(16, activation='relu',kernel_initializer=init(), bias_initializer=init())(flat)
# dense2 = Dense(256, activation='relu',kernel_initializer=init(), bias_initializer=init())(dense1)
dense3 = Dense(8, activation='relu',kernel_initializer=init(), bias_initializer=init())(dense1)
out = Dense(4, activation='relu', name='out',kernel_initializer=init(), bias_initializer=init())(dense3)
all_actions = Dense(action_space_dim, name=scope + 'all_Q', activation="linear",kernel_initializer=init(), bias_initializer=init())(out)
output = keras.layers.dot([all_actions, actions], 1)
model = keras.models.Model(inputs=[inp, actions, weights, rew, pib, pie], outputs=[all_actions])
all_Q = keras.models.Model(inputs=[inp],
outputs=model.get_layer(scope + 'all_Q').output)
rmsprop = keras.optimizers.RMSprop(lr=0.001, rho=0.95, epsilon=1e-08, decay=1e-3)#, clipnorm=1.)
# adam = keras.optimizers.Adam()
model.add_loss(self.MRDR_loss(all_actions, weights, rew, pib, pie))
model.compile(loss=None, optimizer=rmsprop, metrics=['accuracy'])
def get_gradient_norm(model):
with K.name_scope('gradient_norm'):
grads = K.gradients(model.total_loss, model.trainable_weights)
norm = K.sqrt(sum([K.sum(K.square(g)) for g in grads]))
return norm
# Append the "l2 norm of gradients" tensor as a metric
model.metrics_names.append("gradient_norm")
model.metrics_tensors.append(get_gradient_norm(model))
return model, all_Q
def MRDR_loss(self, Q, weights, rew, pib, pie):
# There is numerical instability here on MacOSX. Loss goes negative in TF when overfitting to 1 datapoint but stays positive in Numpy
# sess = K.get_session()
# Omega = sess.run(self.Omega, feed_dict={self.Q_k.input[0]: x,self.Q_k.input[1]: acts,self.Q_k.input[3]:rs, self.Q_k.input[4]:pib, self.Q_k.input[5]:pie})
# sess.run(self.D, feed_dict={self.Q_k.input[0]: x,self.Q_k.input[1]: acts,self.Q_k.input[3]:rs, self.Q_k.input[4]:pib, self.Q_k.input[5]:pie})
# sess.run(self.Q, feed_dict={self.Q_k.input[0]: x,self.Q_k.input[1]: acts,self.Q_k.input[3]:rs, self.Q_k.input[4]:pib, self.Q_k.input[5]:pie})
# qbeta= sess.run(self.qbeta, feed_dict={self.Q_k.input[0]: x,self.Q_k.input[1]: acts,self.Q_k.input[3]:rs, self.Q_k.input[4]:pib, self.Q_k.input[5]:pie})
# sess.run(self.unweighted_loss, feed_dict={self.Q_k.input[0]: x,self.Q_k.input[1]: acts,self.Q_k.input[3]:rs, self.Q_k.input[4]:pib, self.Q_k.input[5]:pie})
# sess.run(self.loss, feed_dict={self.Q_k.input[0]: x,self.Q_k.input[1]: acts,self.Q_k.input[3]:rs, self.Q_k.input[4]:pib, self.Q_k.input[5]:pie})
# Omega = np.array([np.diag(1/x) for x in pib])
# Omega -= 1 #tf.ones_like(Omega)
# D = np.array([np.diag(x) for x in pie])
# qbeta = np.matmul(D, np.expand_dims(self.Q_k_all.predict(x),2)) - np.expand_dims(rs, 2)
# qbeta_T = np.transpose(qbeta, [0,2,1])
# unweighted_loss = np.matmul(np.matmul(qbeta_T, Omega), qbeta)
# loss = np.reshape(weights, (-1,1)) * np.reshape(unweighted_loss, (-1,1))
# return np.reduce_mean(loss)
self.Q = Q
self.rew =rew
self.Omega = tf.matrix_diag(tf.math.divide(1,pib))
self.Omega -= 1 #tf.ones_like(Omega)
self.D = tf.matrix_diag(pie)
self.qbeta = tf.matmul(self.D, tf.expand_dims(Q,2)) - tf.expand_dims(self.rew, 2)
qbeta_T = tf.transpose(self.qbeta, [0,2,1])
self.unweighted_loss = tf.matmul(tf.matmul(qbeta_T, self.Omega), self.qbeta)
self.loss = tf.reduce_mean(self.unweighted_loss)
self.weighted_loss = tf.reshape(weights, (-1,1)) * tf.reshape(self.unweighted_loss, (-1,1)) #weights * self.unweighted_loss
return tf.reduce_mean(tf.squeeze(self.weighted_loss))
def run_NN_tf(self, env, pi_b, pi_e, max_epochs, epsilon=0.001):
initial_states = self.data.initial_states()
self.dim_of_actions = env.n_actions
self.Q_k = None
earlyStopping = EarlyStopping(monitor='val_loss', min_delta=1e-4, patience=10, verbose=1, mode='min', restore_best_weights=True)
reduce_lr_loss = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=7, verbose=1, min_delta=1e-4, mode='min')
self.more_callbacks = [earlyStopping, reduce_lr_loss]
im = self.data.states()[0]
self.g = tf.Graph()
with self.g.as_default():
with tf.variable_scope('mrdr', reuse=False):
self.build_model_(im.shape[1:], 'Q_k', modeltype=self.modeltype, action_space_dim=env.n_actions)
self._init_session()
# self.build_model(im.shape[1:], 'Q_k', modeltype=self.modeltype, action_space_dim=env.n_actions)
batch_size = 32
dataset_length = self.data.num_tuples()
perm = np.random.permutation(range(dataset_length))
perm = np.random.permutation(self.data.idxs_of_non_abs_state())
eighty_percent_of_set = int(1.*len(perm))
training_idxs = perm[:eighty_percent_of_set]
validation_idxs = perm[eighty_percent_of_set:]
training_steps_per_epoch = int(1. * np.ceil(len(training_idxs)/float(batch_size)))
validation_steps_per_epoch = int(np.ceil(len(validation_idxs)/float(batch_size)))
# steps_per_epoch = 1 #int(np.ceil(len(dataset)/float(batch_size)))
train_gen = self.generator(env, pi_e, training_idxs, fixed_permutation=True, batch_size=batch_size)
val_gen = self.generator(env, pi_e, validation_idxs, fixed_permutation=True, batch_size=batch_size, is_train=False)
for i in range(1):
for j in range(max_epochs):
totloss = 0
for k in range(training_steps_per_epoch):
x,y = next(train_gen)
# import pdb; pdb.set_trace()
_, loss = self.sess.run([self.train_op, self.loss], feed_dict={
self.s: x[0],
self.factor: x[2],
self.rew: x[3],
self.pi0: x[4],
self.pi1: x[5],
})
totloss += loss*x[0].shape[0]
print(i, j, k, totloss)
return [],[],self
def run_NN(self, env, pi_b, pi_e, max_epochs, batch_size, epsilon=0.001):
initial_states = self.data.initial_states()
self.dim_of_actions = env.n_actions
self.Q_k, self.Q_k_all = None, None
earlyStopping = EarlyStopping(monitor='val_loss', min_delta=1e-4, patience=10, verbose=1, mode='min', restore_best_weights=True)
reduce_lr_loss = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=7, verbose=1, min_delta=1e-4, mode='min')
self.more_callbacks = [earlyStopping, reduce_lr_loss]
im = self.data.states()[0]
if self.processor: im = self.processor(im)
self.Q_k, self.Q_k_all = self.build_model(im.shape[1:], 'Q_k', modeltype=self.modeltype, action_space_dim=env.n_actions)
# self.Q_k_minus_1, self.Q_k_minus_1_all = self.build_model(im.shape[1:], 'Q_k_minus_1', modeltype=self.modeltype)
values = []
self.Q_k_all.predict([[im[0]]])
print('Training: MRDR')
losses = []
for k in tqdm(range(1)):
dataset_length = self.data.num_tuples()
perm = np.random.permutation(range(dataset_length))
perm = np.random.permutation(self.data.idxs_of_non_abs_state())
eighty_percent_of_set = int(.8*len(perm))
training_idxs = perm[:eighty_percent_of_set]
validation_idxs = perm[eighty_percent_of_set:]
training_steps_per_epoch = int(1. * np.ceil(len(training_idxs)/float(batch_size)))
validation_steps_per_epoch = int(np.ceil(len(validation_idxs)/float(batch_size)))
# steps_per_epoch = 1 #int(np.ceil(len(dataset)/float(batch_size)))
train_gen = self.generator(env, pi_e, training_idxs, fixed_permutation=True, batch_size=batch_size)
val_gen = self.generator(env, pi_e, validation_idxs, fixed_permutation=True, batch_size=batch_size, is_train=False)
# import pdb; pdb.set_trace()
# train_gen = self.generator(env, pi_e, (transitions,frames), training_idxs, fixed_permutation=True, batch_size=batch_size)
# inp, out = next(train_gen)
M = 5
hist = self.Q_k.fit_generator(train_gen,
steps_per_epoch=training_steps_per_epoch,
# validation_data=val_gen,
# validation_steps=validation_steps_per_epoch,
epochs=max_epochs,
max_queue_size=50,
workers=1,
use_multiprocessing=False,
verbose=1,
callbacks = self.more_callbacks)
return np.mean(values[-10:]), self.Q_k, self.Q_k_all
@threadsafe_generator
def generator(self, env, pi_e, all_idxs, fixed_permutation=False, batch_size = 64, is_train=True):
# dataset, frames = dataset
data_length = len(all_idxs)
steps = int(np.ceil(data_length/float(batch_size)))
n = len(self.data)
T = max(self.data.lengths())
n_dim = self.data.n_dim
n_actions = self.data.n_actions
data_dim = n * n_actions * T
omega = n*T * [None]
propensity_weights = []
# r_tild = np.zeros(data_dim)
# for i in tqdm(range(n)):
# states = np.squeeze(self.data.states(low_=i, high_=i+1))
# actions = self.data.actions()[i]
# rewards = self.data.rewards()[i]
# pi0 = self.data.base_propensity()[i]
# pi1 = self.data.target_propensity()[i]
# l = self.data.lengths()[i]
# for t in range(min(T, l)):
# state_t = states[t]
# action_t = actions[t]
# reward_t = rewards[t]
# pib_s_t = pi0[t] #self.policy_behave.pi(state_t)
# pie_s_t = pi1[t] #self.policy_eval.pi(state_t)
# omega_s_t = np.diag(1 / pib_s_t) - 1 #np.ones((n_actions, n_actions))
# D_pi_e = np.diag(pie_s_t)
# if t == 0:
# rho_prev = 1
# else:
# rho_prev = self.rho[i][t-1]
# propensity_weight_t = gamma_vec[t] ** 2 * rho_prev ** 2 * (self.rho[i][t] / rho_prev)
# propensity_weights.append(propensity_weight_t)
# om = propensity_weight_t * D_pi_e.dot(omega_s_t).dot(D_pi_e)
# omega[i * T + t] = om
# t_limit = min(T, l)
# r_tild[(i * T + t) * n_actions + action_t] = np.sum((self.rho[i][t:t_limit] / self.rho[i][t]) *
# (gamma_vec[t:t_limit] / gamma_vec[t]) * rewards[t:])
# Rs = np.array(r_tild).reshape(-1, env.n_actions)
omega = [np.cumprod(om) for om in self.data.omega()]
gamma_vec = self.gamma**np.arange(T)
actions = self.data.actions()
rewards = self.data.rewards()
factors, Rs = [], []
for traj_num, ts in tqdm(enumerate(self.data.ts())):
for t in ts:
i,t = int(traj_num), int(t)
R = np.zeros(env.n_actions)
if omega[i][t]:
R[actions[i,t]] = np.sum( omega[i][t:]/omega[i][t] * gamma_vec[t:]/gamma_vec[t] * rewards[i][t:] )
else:
R[actions[i,t]] = 0
Rs.append(R)
if t == 0:
rho_prev = 1
else:
rho_prev = omega[i][t-1]
if rho_prev:
propensity_weight_t = gamma_vec[t] ** 2 * rho_prev ** 2 * (omega[i][t] / rho_prev)
else:
propensity_weight_t = 0
factors.append(propensity_weight_t)
Rs = np.array(Rs)
factors = np.array(factors) #np.atleast_2d(np.array(factors)).T
states = self.data.states()
original_shape = states.shape
states = states.reshape(-1,np.prod(states.shape[2:]))
actions = np.eye(env.n_actions)[actions.reshape(-1)]
base_propensity = self.data.base_propensity().reshape(-1, env.n_actions)
target_propensity = self.data.target_propensity().reshape(-1, env.n_actions)
while True:
perm = np.random.permutation(all_idxs)
for batch in np.arange(steps):
batch_idxs = perm[(batch*batch_size):((batch+1)*batch_size)]
x = states[batch_idxs].reshape(tuple([-1]) + original_shape[2:])
acts = actions[batch_idxs]
rs = Rs[batch_idxs]
weights = factors[batch_idxs] #* probs[batch_idxs] / np.min(probs)
pib = base_propensity[batch_idxs]
pie = target_propensity[batch_idxs]
if self.processor: x = self.processor(x)
yield ([x, acts, weights, rs, pib, pie], [])
def run(self, pi_e):
n = len(self.data)
T = max(self.data.lengths())
n_dim = self.data.n_dim
n_actions = self.data.n_actions
self.rho = [np.cumprod(om) for om in self.data.omega()]
gamma_vec = self.gamma**np.arange(T)
data_dim = n * n_actions * T
omega = n*T * [None]
r_tild = np.zeros(data_dim)
for i in tqdm(range(n)):
states = np.squeeze(self.data.states(low_=i, high_=i+1))
actions = self.data.actions()[i]
rewards = self.data.rewards()[i]
pi0 = self.data.base_propensity()[i]
pi1 = self.data.target_propensity()[i]
l = self.data.lengths()[i]
for t in range(min(T, l)):
state_t = states[t]
action_t = actions[t]
reward_t = rewards[t]
pib_s_t = pi0[t] #self.policy_behave.pi(state_t)
pie_s_t = pi1[t] #self.policy_eval.pi(state_t)
omega_s_t = np.diag(1 / pib_s_t) - 1 #np.ones((n_actions, n_actions))
D_pi_e = np.diag(pie_s_t)
if t == 0:
rho_prev = 1
else:
rho_prev = self.rho[i][t-1]
if rho_prev:
propensity_weight_t = gamma_vec[t] ** 2 * rho_prev ** 2 * (self.rho[i][t] / rho_prev)
else:
propensity_weight_t = 0
om = propensity_weight_t * D_pi_e.dot(omega_s_t).dot(D_pi_e)
omega[i * T + t] = om
t_limit = min(T, l)
if self.rho[i][t]:
val = np.sum((self.rho[i][t:t_limit] / self.rho[i][t]) * (gamma_vec[t:t_limit] / gamma_vec[t]) * rewards[t:])
else:
val = 0
r_tild[(i * T + t) * n_actions + action_t] = val
self.alpha = 1
self.lamb = 1
self.cond_number_threshold_A = 10000
block_size = int(n_actions * n * T/4)
phi = self.compute_grid_features(pi_e)
self.weights = self.wls_sherman_morrison(phi, r_tild, omega, self.lamb, self.alpha, self.cond_number_threshold_A, block_size)
return self
def compute_feature_without_time(self, state, action, step):
T = max(self.data.lengths())
n_dim = self.data.n_dim
n_actions = self.data.n_actions
if self.modeltype == 'tabular':
phi = np.zeros((n_dim, n_actions))
phi[int(state), int(action)] = 1
phi = phi.reshape(-1)
elif self.modeltype == 'linear':
phi = state.reshape(-1)
else:
raise
return phi
def compute_feature(self, state, action, step):
return self.compute_feature_without_time(state, action, step)
def compute_grid_features(self, pi_e):
n = len(self.data)
T = max(self.data.lengths())
n_dim = self.data.n_dim
n_actions = self.data.n_actions
data_dim = n * T * n_actions
phi = data_dim * [None]
target_propensity = self.data.target_propensity()
for i in range(n):
states = np.squeeze(self.data.states(low_=i, high_=i+1))
l = self.data.lengths()[i]
for t in range(T):
for action in range(n_actions):
if t < l:
s = states[t]
pie_s_t_a_t = target_propensity[i][t][action] #pi_e.predict([states[t]])[0][action]
phi[(i * T + t) * n_actions + action] = pie_s_t_a_t * self.compute_feature(s, action, t)
else:
phi[(i * T + t) * n_actions + action] = np.zeros(len(phi[0]))
return np.array(phi, dtype='float')
def wls_sherman_morrison(self, phi_in, rewards_in, omega_in, lamb, omega_regularizer, cond_number_threshold_A, block_size=None):
# omega_in_2 = block_diag(*omega_in)
# omega_in_2 += omega_regularizer * np.eye(len(omega_in_2))
# Aw = phi_in.T.dot(omega_in_2).dot(phi_in)
# Aw = Aw + lamb * np.eye(phi_in.shape[1])
# print(np.linalg.cond(Aw))
# bw = phi_in.T.dot(omega_in_2).dot(rewards_in)
feat_dim = phi_in.shape[1]
b = np.zeros((feat_dim, 1))
B = np.eye(feat_dim)
data_count = len(omega_in)
if np.isscalar(omega_in[0]):
omega_size = 1
I_a = 1
else:
omega_size = omega_in[0].shape[0]
I_a = np.eye(omega_size)
for i in range(data_count):
if omega_in[i] is None:
# if omega_in[i] is None or (omega_size==1 and omega_in[i] == 0):
#omega_in[i] = I_a
#rewards_in[i] = 1
continue
omeg_i = omega_in[i] + omega_regularizer * I_a
#if omega_size > 1:
# omeg_i = omeg_i / np.max(omeg_i)
feat = phi_in[i * omega_size: (i + 1) * omega_size, :]
# A = A + feat.T.dot(omega_list[i]).dot(feat)
rews_i = np.reshape(rewards_in[i * omega_size: (i + 1) * omega_size], [omega_size, 1])
b = b + feat.T.dot(omeg_i).dot(rews_i)
# Sherman–Morrison–Woodbury formula:
# (B + UCV)^-1 = B^-1 - B^-1 U ( C^-1 + V B^-1 U)^-1 V B^-1
# in our case: U = feat.T C = omega_list[i] V = feat
# print(omeg_i)
if omega_size > 1:
C_inv = np.linalg.inv(omeg_i)
else:
C_inv = 1/omeg_i
if np.linalg.norm(feat.dot(B).dot(feat.T)) < 0.0000001:
inner_inv = omeg_i
else:
inner_inv = np.linalg.inv(C_inv + feat.dot(B).dot(feat.T))
B = B - B.dot(feat.T).dot(inner_inv).dot(feat).dot(B)
weight_prim = B.dot(b)
weight = weight_prim.reshape((-1,))
return weight
def predict(self, x):
if (self.data.n_dim + self.data.n_actions) == x.shape[1]:
acts = np.argmax(x[:,-self.data.n_actions:], axis=1)
S = x[:,:self.data.n_dim]
Q = np.zeros(x.shape[0])
for i, (s, a) in enumerate(zip(S, acts)):
s = int(s)
a = int(a)
Q[i] = np.matmul(self.weights, self.compute_feature(s, a, 0))
return Q
elif (1 + self.data.n_actions) == x.shape[1]:
acts = np.argmax(x[:,-self.data.n_actions:], axis=1)
S = x[:,:1]
Q = np.zeros(x.shape[0])
for i, (s, a) in enumerate(zip(S, acts)):
Q[i] = np.matmul(self.weights, self.compute_feature(s, a, 0))
return Q
elif self.modeltype == 'linear' or self.modeltype == 'tabular':
acts = np.argmax(x[:,-self.data.n_actions:], axis=1)
S = x[:,:-self.data.n_actions]
Q = np.zeros(x.shape[0])
for i, (s, a) in enumerate(zip(S, acts)):
Q[i] = np.matmul(self.weights, self.compute_feature(s, a, 0))
return Q
else:
out = self.sess.run([self.out], feed_dict={
self.s: x
})
return out[0]
# import numpy as np
# import tensorflow as tf
# from time import sleep
# import sys
# import os
# from tqdm import tqdm
# from tensorflow.python import debug as tf_debug
# import json
# import scipy.signal as signal
# from scipy.optimize import linprog
# from scipy.optimize import minimize
# import quadprog
# import scipy
# from scipy.linalg import block_diag
# import pandas as pd
# # Hyper parameter
# from qpsolvers import solve_qp
# from qpsolvers import mosek_solve_qp
# from scipy.sparse import csc_matrix
# import cvxopt
# from cvxopt import matrix
# import sympy
# #Learning_rate = 1e-3
# #initial_stddev = 0.5
# #Training Parameter
# training_batch_size = 128
# training_maximum_iteration = 3001
# TEST_NUM = 2000
# class MRDR_NN(object):
# def __init__(self, obs_dim, w_hidden, Learning_rate, reg_weight, gamma=1.):
# self.action_dim = 3
# self.gamma = gamma
# self.g = tf.Graph()
# with self.g.as_default():
# with tf.variable_scope('mrdr', reuse=False):
# self._build_graph(obs_dim, w_hidden, Learning_rate, reg_weight)
# self._init_session()
# self.g = tf.Graph()
# def q_beta(self):
# return tf.matmul(tf.matrix_diag(self.pi1), tf.expand_dims(self.out,2)) - tf.expand_dims(self.rew, 2)
# def _build_graph(self, obs_dim, w_hidden, Learning_rate, reg_weight):
# # place holder
# tio2 = tf.placeholder(tf.float32, [None], name='policy_ratio2')
# self.s = tf.placeholder(tf.float32, [None] + obs_dim, name='state')
# self.gam = tf.placeholder(tf.float32, [None] , name='gamma_sq')
# self.omega_cumul = tf.placeholder(tf.float32, [None] , name='cumulative_omega')
# self.omega = tf.placeholder(tf.float32, [None] , name='current_omega')
# self.rew = tf.placeholder(tf.float32, [None] + [self.action_dim], name='disc_future_rew')
# self.pi0 = tf.placeholder(tf.float32, [None] + [self.action_dim], name='pi_b')
# self.pi1 = tf.placeholder(tf.float32, [None] + [self.action_dim], name='pi_e')
# # self.factor = self.gam * (self.omega_cumul**2) * self.omega
# self.Omega = tf.matrix_diag(1/self.pi0)
# self.Omega = self.Omega - tf.ones_like(self.Omega)
# self.out = self.Q_val()
# self.q = self.q_beta()
# self.loss_pre_reduce = tf.matmul(tf.matmul(tf.transpose(self.q, [0,2,1]) , self.Omega), self.q)
# self.loss_pre_reduce_w_factor = self.factor * tf.squeeze(self.loss_pre_reduce)
# self.loss = tf.reduce_sum(self.loss_pre_reduce_w_factor)
# self.reg_loss = tf.reduce_sum(tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES, 'mrdr'))
# self.train_op = tf.train.AdamOptimizer(Learning_rate).minimize(self.loss + reg_weight * self.reg_loss)
# # initialize vars
# self.init = tf.global_variables_initializer()
# # Create assign opsfor VAE
# t_vars = tf.trainable_variables()
# self.assign_ops = {}
# for var in t_vars:
# if var.name.startswith('mrdr'):
# pshape = var.get_shape()
# pl = tf.placeholder(tf.float32, pshape, var.name[:-2]+'_placeholder')
# assign_op = var.assign(pl)
# self.assign_ops[var] = (assign_op, pl)
# def _init_session(self):
# """Launch TensorFlow session and initialize variables"""
# self.sess = tf.Session(graph=self.g)
# self.sess.run(self.init)
# def Q_val(self):
# with tf.variable_scope('w', reuse = tf.AUTO_REUSE):
# h = tf.layers.conv2d(self.s, 32, 4, data_format='channels_first', strides=2, activation=tf.nn.relu, name="enc_conv1")
# h = tf.layers.conv2d(h, 64, 4, data_format='channels_first', strides=2, activation=tf.nn.relu, name="enc_conv2")
# h = tf.layers.conv2d(h, 128, 4, data_format='channels_first', strides=2, activation=tf.nn.relu, name="enc_conv3")
# h = tf.layers.conv2d(h, 256, 4, data_format='channels_first', strides=2, activation=tf.nn.relu, name="enc_conv4")
# h = tf.reshape(h, [-1, 3*5*256])
# # Some dense layers
# dense1 = tf.layers.dense(h, 256*3, activation=tf.nn.relu, name="dense1")#, kernel_regularizer = tf.contrib.layers.l2_regularizer(1.), bias_regularizer = regularizer = tf.contrib.layers.l2_regularizer(1.))
# dense2 = tf.layers.dense(dense1, 256, activation=tf.nn.relu, name="dense2")#, kernel_regularizer = tf.contrib.layers.l2_regularizer(1.), bias_regularizer = regularizer = tf.contrib.layers.l2_regularizer(1.))
# out = tf.layers.dense(dense2, self.action_dim, name="Q")
# return out
# def get_density_ratio(self, env, states, starts, batch_size=256):
# bs = batch_size
# num_batches = int(np.ceil(len(states) / bs))
# density = []
# for batch_num in tqdm(range(num_batches)):
# low_ = batch_num * bs
# high_ = (batch_num + 1) * bs
# s = env.pos_to_image(states[low_:high_])
# out=self.sess.run(self.output, feed_dict = {
# self.state : s,
# self.isStart: starts
# })
# density.append(out)
# return np.hstack(density)
# def _train(self, env, dataset, batch_size = training_batch_size, max_iteration = training_maximum_iteration, test_num = TEST_NUM, fPlot = False, epsilon = 1e-3):
# # PI0 = np.vstack([x['base_propensity'] for x in dataset])
# # PI1 = np.vstack([x['target_propensity'] for x in dataset])
# # REW = np.hstack([x['r'] for x in dataset]).T.reshape(-1)
# # ACTS = np.hstack([x['a'] for x in dataset]).reshape(-1)
# # ISSTART = np.hstack([ np.hstack([1] + [0]*(len(x['x'])-1)) for x in dataset])
# # PI0 = PI0[np.arange(len(ACTS)), ACTS]
# # PI1 = PI1[np.arange(len(ACTS)), ACTS]
# PI0 = [x['base_propensity'] for x in dataset]
# PI1 = [x['target_propensity'] for x in dataset]
# ACTS = [x['a'] for x in dataset]
# REW = [x['r'] for x in dataset]
# omega = [np.array(pi1)[range(len(a)), a] /np.array(pi0)[range(len(a)), a] for pi0,pi1,a in zip(PI0, PI1, ACTS)]
# gamma = [[self.gamma**(2*t) for t in range(len(a))] for a in ACTS]
# R = []
# for traj_num, rew in enumerate(REW):
# disc_sum = []
# for i in range(len(rew)):
# disc_sum.append(self.discounted_sum(np.array(rew[i:])*np.cumprod(np.hstack([1, omega[traj_num][(i+1):] ])) , self.gamma))
# R.append(disc_sum)
# omega_cumul = np.hstack([ np.cumprod( np.hstack([1,om[:-1] ]) ) for om in omega])[np.newaxis,...]
# factor = np.hstack(gamma)[np.newaxis,...] * omega_cumul**2 * np.hstack(omega)[np.newaxis,...]
# S = np.vstack([x['x'] for x in dataset])
# SN = np.vstack([x['x_prime'] for x in dataset])
# R = np.hstack(R)
# ACTS = np.hstack(ACTS)
# PI0 = np.vstack(PI0)
# PI1 = np.vstack(PI1)
# # omega_cumul = np.hstack([np.cumprod(om) for om in omega])
# omega = np.hstack(omega)
# gamma = np.hstack(gamma)
# for i in range(max_iteration):
# # if test_num > 0 and i % 100 == 0:
# # subsamples = np.random.choice(test_num, batch_size)
# # s_test = env.pos_to_image(S_test[subsamples])
# # sn_test = env.pos_to_image(SN_test[subsamples])
# # # policy_ratio_test = POLICY_RATIO_test[subsamples]
# # policy_ratio_test = (PI1_test[subsamples] + epsilon)/(PI0_test[subsamples] + epsilon)
# # subsamples = np.random.choice(test_num, batch_size)
# # s_test2 = env.pos_to_image(S_test[subsamples])
# # sn_test2 = env.pos_to_image(SN_test[subsamples])
# # # policy_ratio_test2 = POLICY_RATIO_test[subsamples]
# # policy_ratio_test2 = (PI1_test[subsamples] + epsilon)/(PI0_test[subsamples] + epsilon)
# # start = ISSTART_test[subsamples]
# # # loss_xx, K_xx, diff_xx, left, x, x2, norm_K = self.sess.run([self.loss_xx, self.K_xx, self.diff_xx, self.left, self.x, self.x2, self.norm_K], feed_dict = {self.med_dist: med_dist,self.state: s_test,self.next_state: sn_test,self.policy_ratio: policy_ratio_test,self.state2: s_test2,self.next_state2: sn_test2,self.policy_ratio2: policy_ratio_test2})
# # # import pdb; pdb.set_trace()
# # test_loss, reg_loss, norm_w, norm_w_next = self.sess.run([self.loss,
# # self.reg_loss,
# # self.debug1,
# # self.debug2],
# # feed_dict = {self.med_dist:
# # med_dist,
# # self.state:
# # s_test,
# # self.next_state:
# # sn_test,
# # self.policy_ratio:
# # policy_ratio_test,
# # self.state2:
# # s_test2,
# # self.next_state2:
# # sn_test2,
# # self.policy_ratio2:
# # policy_ratio_test2,
# # self.isStart:
# # start})
# # print('----Iteration = {}-----'.format(i))
# # print("Testing error = {}".format(test_loss))
# # print('Regularization loss = {}'.format(reg_loss))
# # print('Norm_w = {}'.format(norm_w))
# # print('Norm_w_next = {}'.format(norm_w_next))
# # DENR = self.get_density_ratio(env, S_test, ISSTART_test)
# # # T = DENR*POLICY_RATIO2
# # T = DENR*PI1_test/PI0_test
# # # print('DENR = {}'.format(np.sum(T*REW_test)/np.sum(T)))
# # num_traj = sum(ISSTART_test)
# # print('DENR = {}'.format(np.sum(T*REW_test)/num_traj))
# # sys.stdout.flush()
# # # epsilon *= 0.9
# subsamples = np.random.choice(len(S), batch_size)
# s = env.pos_to_image(S[subsamples])
# acts = ACTS[subsamples]
# # _, loss =self.sess.run([self.train_op, self.loss], feed_dict = {
# # self.s: s,
# # self.gam: gam,
# # self.omega_cumul: omega_cumul,
# # self.omega: omega,
# # self.rew: rew,
# # self.pi0: pi0,
# # self.pi1: pi1,
# # self.acts: acts,
# # })
# _, loss, loss_pre_reduce =self.sess.run([self.train_op, self.loss, self.loss_pre_reduce ], feed_dict = {
# # out =self.sess.run([self.db1, self.db2], feed_dict = {
# self.s: s,
# self.gam: gamma[subsamples],
# self.omega_cumul: omega_cumul[subsamples],
# self.omega: omega[subsamples],
# self.rew: np.eye(self.action_dim)[acts] * R[subsamples][...,np.newaxis],
# self.pi0: PI0[subsamples],
# self.pi1: PI1[subsamples],
# self.factor: factor[subsamples]
# })
# print(i, max_iteration, loss)
# # DENR = self.get_density_ratio(env, S)
# # # T = DENR*POLICY_RATIO2
# # T = DENR*PI1/PI0
# # return np.sum(T*REW)/np.sum(T)
# def create(self, env, dataset, filename):
# # S = []
# # POLICY_RATIO = []
# # REW = []
# # for sasr in SASR0:
# # for state, action, next_state, reward in sasr:
# # POLICY_RATIO.append(policy1.pi(state, action)/policy0.pi(state, action))
# # S.append(state)
# # REW.append(reward)
# path = os.path.join(filename, 'mrdr')
# if os.path.isfile(path):
# print('Loading MRDR model')
# self.load_json(path)
# else:
# print('Training MRDR model')
# _ = self._train(env, dataset)
# self.save_json(path)
# def evaluate(self, env, dataset):
# S = np.vstack([x['x'] for x in dataset])
# SN = np.vstack([x['x_prime'] for x in dataset])
# PI0 = np.vstack([x['base_propensity'] for x in dataset])
# PI1 = np.vstack([x['target_propensity'] for x in dataset])
# REW = np.hstack([x['r'] for x in dataset]).T.reshape(-1)
# ACTS = np.hstack([x['a'] for x in dataset]).reshape(-1)
# ISSTART = np.hstack([ np.hstack([1] + [0]*(len(x['x'])-1)) for x in dataset])
# PI0 = PI0[np.arange(len(ACTS)), ACTS]
# PI1 = PI1[np.arange(len(ACTS)), ACTS]
# POLICY_RATIO = PI1/PI0
# # S = np.array(S)
# # S_max = np.max(S, axis = 0)
# # S_min = np.min(S, axis = 0)
# # S = (S - S_min)/(S_max - S_min)
# # POLICY_RATIO = np.array(POLICY_RATIO)
# # REW = np.array(REW)
# DENR = self.get_density_ratio(env, S, ISSTART)
# T = DENR*POLICY_RATIO
# num_traj = sum(ISSTART)
# return np.sum(T*REW)/num_traj#np.sum(T)
# def Q(self, pi_e, s, act):
# Q_val =self.sess.run([self.out], feed_dict = {
# self.s: s,
# })
# return np.array(Q_val)
# def get_model_params(self):
# # get trainable params.
# model_names = []
# model_params = []
# model_shapes = []
# with self.g.as_default():
# t_vars = tf.trainable_variables()
# for var in t_vars:
# if var.name.startswith('mrdr'):
# param_name = var.name
# p = self.sess.run(var)
# model_names.append(param_name)
# params = np.round(p*10000).astype(np.int).tolist()
# model_params.append(params)
# model_shapes.append(p.shape)
# return model_params, model_shapes, model_names
# def set_model_params(self, params):
# with self.g.as_default():
# t_vars = tf.trainable_variables()
# idx = 0
# for var in t_vars:
# if var.name.startswith('mrdr'):
# pshape = tuple(var.get_shape().as_list())
# p = np.array(params[idx])
# assert pshape == p.shape, "inconsistent shape"
# assign_op, pl = self.assign_ops[var]
# self.sess.run(assign_op, feed_dict={pl.name: p/10000.})
# idx += 1
# def load_json(self, jsonfile='mrdr.json'):
# with open(jsonfile, 'r') as f:
# params = json.load(f)
# self.set_model_params(params)
# def save_json(self, jsonfile='mrdr.json'):
# model_params, model_shapes, model_names = self.get_model_params()
# qparams = []
# for p in model_params:
# qparams.append(p)
# with open(jsonfile, 'wt') as outfile:
# json.dump(qparams, outfile, sort_keys=True, indent=0, separators=(',', ': '))
# def discounted_sum(self, costs, discount):
# '''
# Calculate discounted sum of costs
# '''
# y = signal.lfilter([1], [1, -discount], x=costs[::-1])
# return y[::-1][0]
# class MRDR_tabular(object):
# def __init__(self, gamma=1., action_dim=2):
# self.gamma = gamma
# self.action_dim = action_dim
# def discounted_sum(self, costs, discount):
# '''
# Calculate discounted sum of costs
# '''
# y = signal.lfilter([1], [1, -discount], x=costs[::-1])
# return y[::-1][0]
# def run(self, trajectories):
# assert self.action_dim == 2, 'This b1, below, is only right for action_dim = 2'
# PI0 = [x['base_propensity'] for x in trajectories]
# PI1 = [x['target_propensity'] for x in trajectories]
# ACTS = [x['a'] for x in trajectories]
# REW = [x['r'] for x in trajectories]
# omega = [np.array(pi1)[range(len(a)), a] /np.array(pi0)[range(len(a)), a] for pi0,pi1,a in zip(PI0, PI1, ACTS)]
# gamma = [[self.gamma**(2*t) for t in range(len(a))] for a in ACTS]
# R = []
# for traj_num, rew in enumerate(REW):
# disc_sum = []
# for i in range(len(rew)):
# disc_sum.append(self.discounted_sum(np.array(rew[i:])*np.cumprod(np.hstack([1, omega[traj_num][(i+1):] ])) , self.gamma))
# R.append(disc_sum)
# R = np.hstack(R)[np.newaxis,...]
# omega_cumul = np.hstack([ np.cumprod( np.hstack([1,om[:-1] ]) ) for om in omega])[np.newaxis,...]
# factor = np.hstack(gamma)[np.newaxis,...] * omega_cumul**2 * np.hstack(omega)[np.newaxis,...]
# transitions = np.vstack([ factor,
# np.array([x['x'] for x in trajectories]).reshape(-1,1).T ,
# np.array([x['a'] for x in trajectories]).reshape(-1,1).T ,
# R,
# ]).T
# FSAR, idxs, counts = np.unique(transitions, return_index=True, return_counts=True, axis=0)
# propensities = np.hstack([ np.vstack([x['base_propensity'] for x in trajectories]),
# np.vstack([x['target_propensity'] for x in trajectories])
# ])
# propensities = propensities[idxs]
# base_propensity, target_propensity = propensities[:,:len(propensities[0])//2], propensities[:,len(propensities[0])//2:]
# df = pd.DataFrame(np.hstack([FSAR, counts[:,None]]), columns=['factor','s','a','r','counts'])#,'s_','d'])
# self.Q = np.zeros((len(np.unique(df['s'])), self.action_dim))
# self.mapping = {}
# for s, group_df in df.groupby(['s']):
# s = int(s)
# self.mapping[s] = s
# rows = group_df.index.values
# Omega = np.array([np.diag(1/pi0) - 1 for pi0 in base_propensity[rows]])
# D = np.array([np.diag(pi1) for pi1 in target_propensity[rows]])
# pi1 = np.array(target_propensity[rows]).reshape(-1)
# Omega = Omega * group_df['factor'][:,None,None] * group_df['counts'][:, None, None]
# eps = 1e-16 # slack
# block_diag_Omega = block_diag(*Omega)
# # block_diag_Omega = block_diag(*[block_diag_Omega, np.eye((len(Omega)-1)*(self.action_dim))*eps**2])
# P = block_diag_Omega*2 #(block_diag_Omega + block_diag_Omega.T)
# import pdb; pdb.set_trace()
# P = scipy.sparse.lil_matrix(P)
# P = cvxopt.spmatrix(P.tocoo().data, P.tocoo().row, P.tocoo().col)
# actions = np.array(group_df['a']).astype(int)
# rew = np.array(group_df['r'])
# if len(actions) > 1:
# A = scipy.sparse.lil_matrix(scipy.sparse.eye((len(Omega)-1)*(self.action_dim),len(Omega)*self.action_dim ))#+ (len(Omega)-1)*(self.action_dim)))
# for row in np.arange(A.shape[0]):
# A[row, row] = 1 / pi1[:-2][row]
# A[row, row+self.action_dim] = -1 / pi1[2:][row]
# # A[row, len(Omega)*self.action_dim+row] = eps
# A = cvxopt.spmatrix(A.tocoo().data, A.tocoo().row, A.tocoo().col)
# b1 = np.vstack([ np.array([[ (a==0)*(r) ], [0]]) for (a,a2,r,r2) in zip(actions[:-1], actions[1:], rew[:-1], rew[1:]) ]) / pi1[:-2][:, None]
# b2 = np.vstack([ np.array([[ (a2 == 0)*r2], [0]]) for (a,a2,r,r2) in zip(actions[:-1], actions[1:], rew[:-1], rew[1:]) ]) / pi1[2:][:, None]
# b3 = np.vstack([ np.array([[0], [(a== 1)*(r)]]) for (a,a2,r,r2) in zip(actions[:-1], actions[1:], rew[:-1], rew[1:]) ]) / pi1[:-2][:, None]
# b4 = np.vstack([ np.array([[0], [(a2 == 1)*r2]]) for (a,a2,r,r2) in zip(actions[:-1], actions[1:], rew[:-1], rew[1:]) ]) / pi1[2:][:, None]
# b = -b1 + b2 - b3 + b4
# b = cvxopt.matrix(b)
# # Solve min_y y^T P y subject to Ay = b, with some added slack variable inside P to stop ill-conditioning
# # y = self.sparse_solve(P, A, b)
# y = self.quadratic_solver(np.array(matrix(P)), np.array(matrix(A)), np.array(matrix(b)).T[0])
# else:
# y = self.sparse_solve_no_constraint(P)
# # import pdb; pdb.set_trace()
# # np.array(matrix(A)).dot(y) - np.array(matrix(b)).reshape(-1)
# # np.array(matrix(A)).dot(y) - b
# resid = [y[(i*self.action_dim):((i+1)*self.action_dim)].reshape(-1) + (np.eye(self.action_dim)[actions[i]] * rew[i]) for i in range(len(rew))]
# Q = [np.linalg.inv(D[i]).dot(np.array(resid)[i]) for i in range(len(D))]
# self.Q[s] = Q[0]
# # self.Q[s] = np.linalg.inv(D[i]).dot((y[(i*self.action_dim):((i+1)*self.action_dim)][...,np.newaxis] + np.vstack([ [(actions[i]==0)*rew[i]], [(actions[i]==1)*rew[i]] ]) ) ).T[0]
# # for i in range(len(D)): print(np.linalg.inv(D[i]).dot((y[(i*self.action_dim):((i+1)*self.action_dim)][...,np.newaxis] + np.vstack([ [(actions[i]==0)*rew[i]], [(actions[i]==1)*rew[i]] ]) ) ))
# return self.Q, self.mapping
# @staticmethod
# def minitest():
# d1, d2, r1, r2 = 2,-1,3,1
# Omega = np.array([[5., 0.],[0., 10.]])
# A = np.array([[1/d1, -1/d2]])
# b1 = np.array([-r1/d1 + r2/d2])
# q1 = np.zeros(Omega.shape[0])
# G = np.zeros(Omega.shape)
# h1 = np.zeros(Omega.shape[0])
# y = solve_qp(Omega, q1, G, h1, A, b1)
# def get_x(f, d, r):return (f + r) / d
# @staticmethod
# def return_Q(y, A, b):
# # y = output of quad program
# pass
# @staticmethod
# def quadratic_solver(Omega, A, b):
# q = np.zeros(Omega.shape[0])
# G = np.zeros(Omega.shape)
# h = np.zeros(Omega.shape[0])
# y = solve_qp(Omega, q, G, h, A, b)
# return y
# @staticmethod
# def sparse_solve(Omega, A, b):
# q = cvxopt.matrix(0., (Omega.size[0],1))
# # G = cvxopt.spmatrix(0., [0], [0], Omega.size)
# # h = cvxopt.matrix(0., (1,Omega.size[0]))
# y = cvxopt.solvers.coneqp(Omega, q, A=A, b=b)
# print(y)
# return np.array(y['x'])
# @staticmethod
# def sparse_solve_no_constraint(Omega):
# q = cvxopt.matrix(0., (Omega.size[0],1))
# # G = cvxopt.spmatrix(0., [0], [0], Omega.size)
# # h = cvxopt.matrix(0., (1,Omega.size[0]))
# y = cvxopt.solvers.coneqp(Omega, q)
# print(y)
# return np.array(y['x'])
| 51,705 | 44.276708 | 370 | py |
SOPE | SOPE-master/ope/utls/agent.py | import gym
import random
import numpy as np
import tensorflow as tf
from skimage.color import rgb2gray
from skimage.transform import resize
from keras.models import Sequential
from keras.layers import Dense, Flatten
from keras.layers.convolutional import Conv2D
from keras import backend as K
EPISODES = 50000
class TestAgent:
def __init__(self, action_size):
self.state_size = (84, 84, 4)
self.action_size = action_size
self.no_op_steps = 20
self.model = self.build_model()
self.sess = tf.InteractiveSession()
K.set_session(self.sess)
self.avg_q_max, self.avg_loss = 0, 0
self.sess.run(tf.global_variables_initializer())
def build_model(self):
model = Sequential()
model.add(Conv2D(32, (8, 8), strides=(4, 4), activation='relu',
input_shape=self.state_size))
model.add(Conv2D(64, (4, 4), strides=(2, 2), activation='relu'))
model.add(Conv2D(64, (3, 3), strides=(1, 1), activation='relu'))
model.add(Flatten())
model.add(Dense(512, activation='relu'))
model.add(Dense(self.action_size))
model.summary()
return model
def get_action(self, history):
if np.random.random() < 0.01:
return random.randrange(3)
history = np.float32(history / 255.0)
q_value = self.model.predict(history)
return np.argmax(q_value[0])
def load_model(self, filename):
self.model.load_weights(filename)
def pre_processing(observe):
processed_observe = np.uint8(
resize(rgb2gray(observe), (84, 84), mode='constant') * 255)
return processed_observe
| 1,674 | 29.454545 | 72 | py |
SOPE | SOPE-master/ope/utls/rollout.py |
from tqdm import tqdm
import numpy as np
import os
import json
import pandas as pd
from collections import Counter
from keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
import keras
from keras.models import Sequential
from keras.layers import Dense, Conv2D, Flatten, MaxPool2D, concatenate, UpSampling2D, Reshape, Lambda
from keras.optimizers import Adam
from keras import backend as K
import tensorflow as tf
from ope.utls.thread_safe import threadsafe_generator
from keras import regularizers
class DataHolder(object):
def __init__(self, s, a, r, s_, d, policy_action, original_shape):
self.states = s
self.next_states = s_
self.actions = a
self.rewards = r
self.dones = d
self.policy_action = policy_action
self.original_shape = original_shape
class Data(object):
def __init__(self, trajectories, n_actions, n_dim, make_int=False):
self.trajectories = trajectories
self.n_actions = n_actions
self.n_dim = n_dim
self.make_int = make_int
if self.make_int:
self.process = lambda x: x.astype('uint8')
else:
self.process = lambda x: x
def __getstate__(self):
dic = {}
dic['traj'] = self.trajectories
dic['n_actions'] = self.n_actions
dic['n_dim'] = self.n_dim
dic['make_int'] = self.make_int
return dic
def __setstate__(self, dic):
self.trajectories = dic['traj']
self.n_actions = dic['n_actions']
self.n_dim = dic['n_dim']
self.make_int = dic['make_int']
def copy(self, low_=None, high_=None):
if (low_ is not None) and (high_ is not None):
return Data(self.trajectories[low_:high_], self.n_actions, self.n_dim, self.make_int)
elif (low_ is not None):
return Data(self.trajectories[low_:], self.n_actions, self.n_dim, self.make_int)
elif (high_ is not None):
return Data(self.trajectories[:high_], self.n_actions, self.n_dim, self.make_int)
else:
return Data(self.trajectories, self.n_actions, self.n_dim, self.make_int)
def bootstrap(self, N):
idxs = np.random.randint(0, len(self.trajectories), N)
return Data([self.trajectories[x] for x in idxs], self.n_actions, self.n_dim, self.make_int)
def frames(self, trajectory_wise=True):
if trajectory_wise:
return np.array([data['frames'] for data in self.trajectories])
else:
return np.array([data['frames'] for data in self.trajectories]).reshape(-1,1).T
def states(self, trajectory_wise=True, low_=None, high_=None):
if low_ is not None and high_ is not None:
episodes = self.trajectories[low_:high_]
# pos = np.vstack([np.vstack(x['x']) for x in episodes])
# N = np.hstack([[low_ + n]*len(x['x']) for n,x in enumerate(episodes)])
# X = np.array([np.array(self.frames()[int(N[idx])])[pos[idx].astype(int)] for idx in range(len(pos))])
X = np.array([ self.process(np.array(self.trajectories[low_ + idx]['frames'])[np.array(x)]) for idx, x in enumerate([x['x'] for x in episodes])])
elif low_ is not None:
episodes = self.trajectories[low_:]
# pos = np.vstack([np.vstack(x['x']) for x in episodes])
# N = np.hstack([[low_ + n]*len(x['x']) for n,x in enumerate(episodes)])
# X = np.array([np.array(self.frames()[int(N[idx])])[pos[idx].astype(int)] for idx in range(len(pos))])
X = np.array([ self.process(np.array(self.trajectories[low_ + idx]['frames'])[np.array(x)]) for idx, x in enumerate([x['x'] for x in episodes])])
elif high_ is not None:
episodes = self.trajectories[:high_]
# pos = np.vstack([np.vstack(x['x']) for x in episodes])
# N = np.hstack([[n]*len(x['x']) for n,x in enumerate(episodes)])
# X = np.array([np.array(self.frames()[int(N[idx])])[pos[idx].astype(int)] for idx in range(len(pos))])
X = np.array([ self.process(np.array(self.trajectories[idx]['frames'])[np.array(x)]) for idx, x in enumerate([x['x'] for x in episodes])])
else:
X = np.array([ self.process(np.array(self.trajectories[idx]['frames'])[np.array(x)]) for idx, x in enumerate([x['x'] for x in self.trajectories])])
X = self.process(X)
if trajectory_wise:
return X
else:
return self.process(np.vstack(X))
# def states(self, trajectory_wise=True):
# if trajectory_wise:
# return np.array([data['x'] for data in self.trajectories])
# else:
# return np.array([data['x'] for data in self.trajectories]).reshape(-1,1).T
def initial_states(self):
return self.states()[:,0]
def actions(self, trajectory_wise=True):
if trajectory_wise:
return np.array([data['a'] for data in self.trajectories])
else:
return np.array([data['a'] for data in self.trajectories]).reshape(-1,1).T
def rewards(self, trajectory_wise=True):
if trajectory_wise:
return np.array([data['r'] for data in self.trajectories])
else:
return np.array([data['r'] for data in self.trajectories]).reshape(-1,1).T
def next_states(self, trajectory_wise=True, low_=None, high_=None):
if low_ is not None and high_ is not None:
episodes = self.trajectories[low_:high_]
X = np.array([ self.process(np.array(self.trajectories[low_ + idx]['frames'])[np.array(x)]) for idx, x in enumerate([x['x_prime'] for x in episodes])])
elif low_ is not None:
episodes = self.trajectories[low_:]
X = np.array([ self.process(np.array(self.trajectories[low_ + idx]['frames'])[np.array(x)]) for idx, x in enumerate([x['x_prime'] for x in episodes])])
elif high_ is not None:
episodes = self.trajectories[:high_]
X = np.array([ self.process(np.array(self.trajectories[idx]['frames'])[np.array(x)]) for idx, x in enumerate([x['x_prime'] for x in episodes])])
else:
X = np.array([ self.process(np.array(self.trajectories[idx]['frames'])[np.array(x)]) for idx, x in enumerate([x['x_prime'] for x in self.trajectories])])
X = self.process(X)
if trajectory_wise:
return X
else:
return self.process(np.vstack(X))
def dones(self, trajectory_wise=True):
if trajectory_wise:
return np.array([data['done'] for data in self.trajectories])
else:
return np.array([data['done'] for data in self.trajectories]).reshape(-1,1).T
def base_propensity(self, trajectory_wise=True):
if trajectory_wise:
return np.array([data['base_propensity'] for data in self.trajectories])
else:
return np.array([data['base_propensity'] for data in self.trajectories]).reshape(-1,1).T
def target_propensity(self, trajectory_wise=True):
if trajectory_wise:
return np.array([data['target_propensity'] for data in self.trajectories])
else:
return np.array([data['target_propensity'] for data in self.trajectories]).reshape(-1,1).T
def next_target_propensity(self, trajectory_wise=True):
if trajectory_wise:
return np.array([data['target_propensity'][1:] + [data['extra_propensity']] for data in self.trajectories])
else:
return np.array([data['target_propensity'][1:] + [data['extra_propensity']] for data in self.trajectories]).reshape(-1,1).T
def input_shape(self, process):
return list(process(np.array(self.trajectories[0]['x'][0])[np.newaxis,...]).shape[1:])
def num_states(self):
return len(np.unique([x['frames'] for x in self.trajectories]))
def ts(self, trajectory_wise=True):
if trajectory_wise:
return np.array([range(len(x['x'])) for x in self.trajectories])
else:
return np.array([range(len(x['x'])) for x in self.trajectories]).reshape(-1,1).T
def lengths(self):
return np.array([len(x['x']) for x in self.trajectories])
def num_tuples(self):
return sum(self.lengths())
def idxs_of_non_abs_state(self):
dones = self.dones()
dones = np.hstack([np.zeros((dones.shape[0],1)), dones,])[:,:-1]
return np.where((1-dones).reshape(-1))[0]
def value_of_trajectory(self, i, gamma, normalized=False):
gammas = gamma**np.arange(len(self.trajectories[i]['x']))
if normalized:
return np.sum( gammas * self.trajectories[i]['r'] ), np.sum( gammas )
else:
return np.sum( gammas * self.trajectories[i]['r'] ), 0
def value_of_data(self, gamma, normalized=False):
s, norm = 0, 0
for i in np.arange(len(self)):
val, normalization = self.value_of_trajectory(i, gamma, normalized)
s += val
norm += normalization
if normalized:
return s/norm
else:
return s/len(self)
def __len__(self):
return len(self.trajectories)
def all_transitions(self):
''' for mle '''
policy_action = np.vstack([episode['target_propensity'] for episode in self.trajectories])
dataset = np.hstack([ np.vstack([x['x'] for x in self.trajectories]),
np.hstack([x['a'] for x in self.trajectories]).T.reshape(-1, 1),
np.hstack([x['r'] for x in self.trajectories]).T.reshape(-1, 1),
np.vstack([x['x_prime'] for x in self.trajectories]),
np.hstack([x['done'] for x in self.trajectories]).T.reshape(-1, 1),
policy_action,
np.hstack([[n]*len(x['x']) for n,x in enumerate(self.trajectories)]).T.reshape(-1,1),
np.hstack([np.arange(len(x['x'])) for n,x in enumerate(self.trajectories)]).T.reshape(-1,1),])
return dataset
def basic_transitions(self):
''' for fqe'''
frames = np.array([x['frames'] for x in self.trajectories])
data = np.vstack([frames[:,:-1].reshape(-1),
np.array([x['a'] for x in self.trajectories]).reshape(-1,1).T,
np.array([range(len(x['x'])) for x in self.trajectories]).reshape(-1,1).T,
frames[:,1:].reshape(-1),
np.array([x['r'] for x in self.trajectories]).reshape(-1,1).T,
np.array([x['done'] for x in self.trajectories]).reshape(-1,1).T]).T
return data
def omega(self):
return np.array([[episode['target_propensity'][idx][int(act)]/episode['base_propensity'][idx][int(act)] for idx,act in enumerate(episode['a'])] for episode in self.trajectories])
def estimate_propensity(self, use_NN=False):
# WARN: Only works in tabular env with discrete action space. Current implementation is a max likelihood
if not use_NN:
data = self.basic_transitions()
propensity = np.ones((self.n_dim, self.n_actions))/self.n_actions
df = pd.DataFrame(data[:, [0, 1]], columns=['x','a'])
terminal = np.max(df['x']) # handle terminal condition
for (x), group in df.groupby(['x']):
new_propensity = np.zeros(self.n_actions)
count_per_action = Counter(group['a'])
for action, count in count_per_action.items():
new_propensity[int(action)] = count/len(group)
new_propensity += 1e-8
propensity[int(x)] = new_propensity / sum(new_propensity)
for episode_num, states in enumerate(np.squeeze(self.states())):
base_propensity = []
for state in states:
base_propensity.append(propensity[state].tolist())
self.trajectories[episode_num]['base_propensity'] = base_propensity
else:
def init(): return keras.initializers.TruncatedNormal(mean=0.0, stddev=0.1, seed=np.random.randint(2**32))
scope = 'pi_b'
inp = keras.layers.Input(self.states()[0][0].shape, name='frames')
actions = keras.layers.Input((self.n_actions,), name='mask')
def init(): return keras.initializers.TruncatedNormal(mean=0.0, stddev=0.001, seed=np.random.randint(2**32))
conv1 = Conv2D(16, (2,2), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(inp)
# pool1 = MaxPool2D(data_format='channels_first')(conv1)
# conv2 = Conv2D(16, (2,2), strides=(1,1), padding='same', data_format='channels_first', activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(pool1)
# pool2 = MaxPool2D(data_format='channels_first')(conv2)
flat1 = Flatten(name='flattened')(conv1)
out = Dense(8, activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(flat1)
out = Dense(8, activation='elu',kernel_initializer=init(), bias_initializer=init(), kernel_regularizer=regularizers.l2(1e-6))(out)
all_actions = Dense(self.n_actions, name=scope, activation="softmax",kernel_initializer=init(), bias_initializer=init())(out)
model = keras.models.Model(inputs=inp, outputs=all_actions)
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
self.processed_data = self.fill()
batch_size = 32
dataset_length = self.num_tuples()
perm = np.random.permutation(range(dataset_length))
eighty_percent_of_set = int(.8*len(perm))
training_idxs = perm[:eighty_percent_of_set]
validation_idxs = perm[eighty_percent_of_set:]
training_steps_per_epoch = int(np.ceil(len(training_idxs)/float(batch_size)))
validation_steps_per_epoch = int(np.ceil(len(validation_idxs)/float(batch_size)))
train_gen = self.generator(training_idxs, fixed_permutation=True, batch_size=batch_size)
val_gen = self.generator(validation_idxs, fixed_permutation=True, batch_size=batch_size)
earlyStopping = EarlyStopping(monitor='val_loss', min_delta=1e-4, patience=10, verbose=1, mode='min', restore_best_weights=True)
reduce_lr_loss = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=7, verbose=1, min_delta=1e-4, mode='min')
more_callbacks = [earlyStopping, reduce_lr_loss]
hist = model.fit_generator(train_gen,
steps_per_epoch=training_steps_per_epoch,
validation_data=val_gen,
validation_steps=validation_steps_per_epoch,
epochs=30,
max_queue_size=50,
workers=2,
use_multiprocessing=False,
verbose=1,
callbacks = more_callbacks)
for episode_num, states in enumerate(np.squeeze(self.states())):
base_propensity = []
for state in states:
base_propensity.append(model.predict(state[None,None,...])[0].tolist())
self.trajectories[episode_num]['base_propensity'] = base_propensity
def fill(self):
states = self.states()
states = states.reshape(-1,np.prod(states.shape[2:]))
actions = self.actions().reshape(-1)
actions = np.eye(self.n_actions)[actions]
next_states = self.next_states()
original_shape = next_states.shape
next_states = next_states.reshape(-1,np.prod(next_states.shape[2:]))
policy_action = self.target_propensity().reshape(-1, self.n_actions)
rewards = self.rewards().reshape(-1)
dones = self.dones()
dones = dones.reshape(-1)
return DataHolder(states, actions, rewards, next_states, dones, policy_action, original_shape)
@threadsafe_generator
def generator(self, all_idxs, fixed_permutation=False, batch_size = 64):
states = self.processed_data.states
actions = self.processed_data.actions
next_states = self.processed_data.next_states
original_shape = self.processed_data.original_shape
policy_action = self.processed_data.policy_action
rewards = self.processed_data.rewards
dones = self.processed_data.dones
data_length = len(all_idxs)
steps = int(np.ceil(data_length/float(batch_size)))
alpha = 1.
while True:
perm = np.random.permutation(all_idxs)
for batch in np.arange(steps):
batch_idxs = perm[(batch*batch_size):((batch+1)*batch_size)]
x = states[batch_idxs].reshape(tuple([-1]) + original_shape[2:])
acts = actions[batch_idxs]
yield (x, acts)
def rollout(env, pi_b, process, absorbing_state, pi_e = None, N=10000, T=200, frameskip=1, frameheight=1, path=None, filename='tmp',preprocessor=None, visualize=False, no_op_steps=0, use_only_last_reward=False):
# filename = os.path.join(path, filename % (N, frameskip))
# try:
# with open(filename) as jsonfile:
# trajectories = json.load(jsonfile)
# except:
trajectories = []
for i in tqdm(range(N)):
done = False
state = env.reset()
if no_op_steps > 0:
for _ in range(3):
state, _, _, _ = env.step(1) #random action?
true_state = state[:]
episode = {'true_state': [],
'true_next_state': [],
'x': [],
'a': [],
'r': [],
'x_prime': [],
'done': [],
'base_propensity': [],
'target_propensity': [],
'frames': [],
'extra_propensity': []}
t = 0
if preprocessor:
frames = [preprocessor(np.array([true_state]))]*frameheight #+ [absorbing_state]*(frameheight-1)
all_frames = [t]*frameheight
episode['frames'].append(frames[0])
else:
frames = [true_state]*frameheight
all_frames = [t]*frameheight
episode['frames'].append(state.tolist())
N_acts = None
if visualize and (i == 0):
import matplotlib.pyplot as plt
plt.imsave('./videos/enduro/%s_%05d.jpg' % (visualize, t), env.render(mode='rgb_array'))
while (t < T): # and (not done):
# im = env.pos_to_image(np.array(frames)[np.newaxis, ...])
if not done:
im = process(np.array(frames)[np.newaxis, ...])
# im = np.array(frames)[np.newaxis, ...]
action = int(pi_b.sample(im))#pi_b([state])
if N_acts is None: N_acts = len(pi_b.predict(im).tolist()[0])
episode['base_propensity'].append(pi_b.predict(im).tolist()[0])
if pi_e is not None:
episode['target_propensity'].append(pi_e.predict(im).tolist()[0])
reward = 0
for _ in range(frameskip):
if done:
new_state, rew, done = absorbing_state, 0, True
continue
try:
if pi_b.action_map is not None:
new_state, rew, done, info = env.step(pi_b.get_action(action))
else:
new_state, rew, done, info = env.step(action)
except:
new_state, rew, done, info = env.step(action)
reward += rew/frameskip
if visualize and (i == 0):
plt.imsave('./videos/enduro/%s_%05d.jpg' % (visualize, t), env.render(mode='rgb_array'))
if use_only_last_reward:
reward = rew
true_state = new_state
else:
action = 0
# propensity = [1/N_acts]*N_acts
# propensity[-1] = 1 - sum(propensity[:-1])
# import pdb; pdb.set_trace()
propensity = [1e-8] * N_acts
propensity[action] += 1 - sum(propensity)
episode['base_propensity'].append(propensity)
if pi_e is not None:
episode['target_propensity'].append(propensity)
new_state, reward, done = absorbing_state, 0, True
true_state = new_state
t += 1
if preprocessor:
frames.append(preprocessor(np.array([true_state])))
else:
frames.append(true_state)
all_frames += [t]
x = all_frames[:-1]
x_ = all_frames[1:]
all_frames.pop(0)
frames.pop(0)
episode['x'].append(x)
episode['a'].append(action)
episode['r'].append(reward)
episode['x_prime'].append(x_)
episode['done'].append(done)
# if len(episode['frames'])== 50: import pdb; pdb.set_trace()
if preprocessor:
episode['frames'].append(preprocessor(np.array([new_state])))
else:
episode['frames'].append(new_state.tolist())
state = new_state
episode['frames'][-1] = preprocessor(np.array([absorbing_state])).tolist() if preprocessor else absorbing_state.tolist()
if pi_e is not None:
if len(state) > 1:
if np.all(state == absorbing_state):
propensity = [1e-8] * N_acts
propensity[action] += 1 - sum(propensity)
episode['extra_propensity'] = propensity
else:
im = process(np.array(frames)[np.newaxis, ...])
episode['extra_propensity'] = pi_e.predict(im).tolist()[0]
else:
if state == absorbing_state:
propensity = [1e-8] * N_acts
propensity[action] += 1 - sum(propensity)
episode['extra_propensity'] = propensity
else:
im = process(np.array(frames)[np.newaxis, ...])
episode['extra_propensity'] = pi_e.predict(im).tolist()[0]
trajectories.append(episode)
# with open(filename, 'w') as fout:
# json.dump(trajectories, fout, indent= 4)
try:
as_int = env.save_as_int
except:
as_int = False
return Data(trajectories, env.n_actions, env.n_dim, as_int)
| 23,124 | 44.882937 | 218 | py |
SOPE | SOPE-master/ope/experiment_tools/experiment.py | import json
import argparse
import matplotlib as mpl
import matplotlib.pyplot as plt
import scipy.signal as signal
import os
from skimage.transform import rescale, resize, downscale_local_mean
import json
from collections import OrderedDict, Counter
import tensorflow as tf
from keras.models import load_model, model_from_json
from keras import backend as K
import time
import argparse
import boto3
import glob
import numpy as np
import sys
from pdb import set_trace as b
import numpy as np
from skimage.color import rgb2gray
from skimage.transform import resize
from ope.algos.doubly_robust_v2 import DoublyRobust_v2 as DR
from ope.algos.fqe import FittedQEvaluation
from ope.algos.magic import MAGIC
from ope.algos.average_model import AverageModel as AM
from ope.algos.sequential_DR import SeqDoublyRobust as SeqDR
from ope.algos.dm_regression import DirectMethodRegression as DM
from ope.algos.traditional_is import TraditionalIS as IS
from ope.algos.infinite_horizon import InfiniteHorizonOPE as IH
from ope.algos.event_is import EventIS
from ope.algos.dm_regression import DirectMethodRegression
from ope.algos.more_robust_doubly_robust import MRDR
from ope.algos.retrace_lambda import Retrace
from ope.models.approximate_model import ApproxModel
from ope.models.basics import BasicPolicy
from ope.models.epsilon_greedy_policy import EGreedyPolicy
from ope.models.max_likelihood import MaxLikelihoodModel
from ope.models.Q_wrapper import QWrapper
from ope.models.tabular_model import TabularPolicy
from ope.utls.get_Qs import getQs
from ope.utls.rollout import rollout, Data
from ope.utils import keyboard
def analysis(dic):
divergence = -1
if 'KLDivergence' in dic:
divergence = dic['KLDivergence']
del dic['KLDivergence']
longest = max([len(key) for key,_ in dic.items()])
sorted_keys = np.array([[key,val[1]] for key,val in dic.items()])
sorted_keys = sorted_keys[np.argsort(sorted_keys[:,1].astype(float))]
# sorted_keys = sorted_keys[sorted(sorted_ke)]
print ("Results: \n")
for key, value in dic.items():
label = ' '*(longest-len(key)) + key
print("{}: {:10.4f}. Error: {:10.4f}".format(label, *value))
print('\n')
print ("Ordered Results: \n")
for key in sorted_keys[:,0]:
value = dic[key]
label = ' '*(longest-len(key)) + key
print("{}: {:10.4f}. Error: {:10.4f}".format(label, *value))
dic['KLDivergence'] = divergence
return dic
class Result(object):
def __init__(self, cfg, result):
self.cfg = cfg
self.result = result
class ExperimentRunner(object):
def __init__(self):
self.results = []
self.cfgs = []
def add(self, cfg):
self.cfgs.append(cfg)
def run(self):
"""
Returns:
result: a dictionary mapping name of estimator to a list s.t. result[NAME][0] is
the estimate and result[NAME][1] is the error
"""
results = []
trial = 1
all_eval_data = None
for cfg in self.cfgs:
trial += 1
if cfg.modeltype == 'tabular':
all_Nval_results, trial_eval_data = self.run_tabular(cfg, all_eval_data, trial)
results += all_Nval_results
if all_eval_data is None:
all_eval_data = trial_eval_data
else:
all_Nval_results, trial_eval_data = self.run_NN(cfg, all_eval_data, trial)
results += all_Nval_results
if all_eval_data is None:
all_eval_data = trial_eval_data
return results
def get_rollout(self, cfg, eval_data=False, N_overwrite = None):
env = cfg.env
pi_e = cfg.pi_e
pi_b = cfg.pi_b
processor = cfg.processor
absorbing_state = cfg.absorbing_state
T = cfg.horizon
frameskip = cfg.frameskip if cfg.frameskip is not None else 1
frameheight = cfg.frameheight if cfg.frameheight is not None else 1
use_only_last_reward = cfg.use_only_last_reward if cfg.use_only_last_reward is not None else False
if eval_data:
data = rollout(env, pi_e, processor, absorbing_state, N=max(10000, cfg.num_traj) if N_overwrite is None else N_overwrite, T=T, frameskip=frameskip, frameheight=frameheight, path=None, filename='tmp', use_only_last_reward=use_only_last_reward)
else:
data = rollout(env, pi_b, processor, absorbing_state, pi_e = pi_e, N=cfg.num_traj, T=T, frameskip=frameskip, frameheight=frameheight, path=None, filename='tmp',use_only_last_reward=use_only_last_reward)
return data
def run_tabular(self, cfg, all_eval_data=None, trial=None):
env = cfg.env
pi_e = cfg.pi_e
pi_b = cfg.pi_b
processor = cfg.processor
absorbing_state = cfg.absorbing_state
T = cfg.horizon
gamma = cfg.gamma
models = cfg.models
if isinstance(models, str):
if models == 'all':
models = ['MFree_Retrace_L', 'MFree_MRDR', 'MFree_IH', 'MFree_FQE', 'MBased_MLE', 'MFree_Reg', 'IS', 'MFree_NStep']
elif models == 'n-step':
models = ['MFree_NStep', 'MFree_IH', 'IS']
else:
raise ValueError("Please give valid value of models")
# Generate dataset for the largest data size.
if all_eval_data is None:
all_eval_data = rollout(env, pi_e, processor, absorbing_state, N=max(10000, cfg.num_traj), T=T, frameskip=1, frameheight=1, path=None, filename='tmp',)
all_behavior_data = rollout(env, pi_b, processor, absorbing_state, pi_e = pi_e, N=cfg.num_traj, T=T, frameskip=1, frameheight=1, path=None, filename='tmp',)
if cfg.to_regress_pi_b:
all_behavior_data.estimate_propensity()
true = all_eval_data.value_of_data(gamma, False)
print('V(pi_b): ',all_behavior_data.value_of_data(gamma, False), 'V(pi_b) Normalized: ',all_behavior_data.value_of_data(gamma, True))
print('V(pi_e): ',all_eval_data.value_of_data(gamma, False), 'V(pi_e) Normalized: ',all_eval_data.value_of_data(gamma, True))
# Compute the estimate for different amounts of data.
all_Nval_results = []
for Nval in cfg.Nvals:
# Store results for computation for this Nval.
dic = {}
dic.update({'ON POLICY': [float(true), 0]})
# Get first Nval trajectories in dataset.
subset_behavior_data = Data(all_behavior_data.trajectories[:Nval],
all_behavior_data.n_actions,
all_behavior_data.n_dim,
all_behavior_data.make_int)
# Compute Qs.
get_Qs = getQs(subset_behavior_data, pi_e, processor, env.n_actions)
# Compute each type of estimate.
for model in models:
if model == 'MBased_MLE':
env_model = MaxLikelihoodModel(gamma, max_traj_length=T, action_space_dim=env.n_actions)
env_model.run(subset_behavior_data)
Qs_model_based = get_Qs.get(env_model)
out = self.estimate(Qs_model_based, subset_behavior_data, gamma, 'Model Based', true)
dic.update(out)
elif model == 'MBased_Approx':
print('*'*20)
print('Approx estimator not implemented for tabular state space. Please use MBased_MLE instead')
print('*'*20)
elif model == 'MFree_Reg':
DMRegression = DirectMethodRegression(subset_behavior_data, gamma, None, None, None)
dm_model_ = DMRegression.run(pi_b, pi_e)
dm_model = QWrapper(dm_model_, {}, is_model=True, modeltype='linear', action_space_dim=env.n_actions)
Qs_DM_based = get_Qs.get(dm_model)
out = self.estimate(Qs_DM_based, subset_behavior_data, gamma,'DM Regression', true)
dic.update(out)
elif model == 'MFree_FQE':
FQE = FittedQEvaluation(subset_behavior_data, gamma)
out0, Q, mapping = FQE.run(pi_b, pi_e)
fqe_model = QWrapper(Q, mapping, is_model=False, action_space_dim=env.n_actions)
Qs_FQE_based = get_Qs.get(fqe_model)
out = self.estimate(Qs_FQE_based, subset_behavior_data, gamma, 'FQE', true)
dic.update(out)
elif model == 'MFree_IH':
ih_max_epochs = None
matrix_size = None
inf_horizon = IH(subset_behavior_data, 30, 1e-3, 3e-3, gamma, True, None, env=env, weighted=cfg.weighted)
inf_hor_output = inf_horizon.evaluate(env, ih_max_epochs, matrix_size)
inf_hor_output /= 1/np.sum(gamma ** np.arange(max(subset_behavior_data.lengths())))
dic.update({'IH': [inf_hor_output, (inf_hor_output - true )**2]})
elif model == 'MFree_NStep':
event_max_epochs = None
matrix_size = None
event_is = EventIS(data=subset_behavior_data, w_hidden=30, Learning_rate=1e-4, reg_weight=3e-3, gamma=gamma, discrete=True, modeltype=None, env=env, interp_type="n-step", weighted=cfg.weighted)
if (cfg.nstep_custom_ns is not None):
all_event_output = event_is.evaluate(env, event_max_epochs, matrix_size, nstep_custom_ns=cfg.nstep_custom_ns)
for i in cfg.nstep_custom_ns:
dic.update({'NStep(t=%d)'%i: [all_event_output[i], (all_event_output[i] - true )**2]})
else:
all_event_output = event_is.evaluate(env, event_max_epochs, matrix_size, nstep_int=cfg.nstep_int)
for i in range(0, subset_behavior_data.states().shape[1]+1, cfg.nstep_int):
dic.update({'NStep(t=%d)'%i: [all_event_output[i], (all_event_output[i] - true )**2]})
elif model == 'MFree_MRDR':
mrdr = MRDR(subset_behavior_data, gamma, modeltype = 'tabular')
_ = mrdr.run(pi_e)
mrdr_model = QWrapper(mrdr, {}, is_model=True, modeltype='linear', action_space_dim=env.n_actions) # annoying missname of variable. fix to be modeltype='tabular'
Qs_mrdr_based = get_Qs.get(mrdr_model)
out = self.estimate(Qs_mrdr_based, subset_behavior_data, gamma, 'MRDR', true)
dic.update(out)
elif model == 'MFree_Retrace_L':
retrace = Retrace(subset_behavior_data, gamma, lamb=1.)
out0, Q, mapping = retrace.run(pi_b, pi_e, 'retrace', epsilon=.001)
retrace_model = QWrapper(Q, mapping, is_model=False, action_space_dim=env.n_actions)
Qs_retrace_based = get_Qs.get(retrace_model)
out = self.estimate(Qs_retrace_based, subset_behavior_data, gamma, 'Retrace(lambda)', true)
dic.update(out)
out0, Q, mapping = retrace.run(pi_b, pi_e, 'tree-backup', epsilon=.001)
retrace_model = QWrapper(Q, mapping, is_model=False, action_space_dim=env.n_actions)
Qs_retrace_based = get_Qs.get(retrace_model)
out = self.estimate(Qs_retrace_based, subset_behavior_data, gamma, 'Tree-Backup', true)
dic.update(out)
out0, Q, mapping = retrace.run(pi_b, pi_e, 'Q^pi(lambda)', epsilon=.001)
retrace_model = QWrapper(Q, mapping, is_model=False, action_space_dim=env.n_actions)
Qs_retrace_based = get_Qs.get(retrace_model)
out = self.estimate(Qs_retrace_based, subset_behavior_data, gamma, 'Q^pi(lambda)', true)
dic.update(out)
elif model == 'IS':
out = self.estimate([], subset_behavior_data, gamma, 'IS', true, True)
dic.update(out)
else:
print(model, ' is not a valid method')
result = analysis(dic)
result["Nval"] = Nval
self.results.append(Result(cfg, result))
all_Nval_results.append(result)
return all_Nval_results, all_eval_data
def run_NN(self, cfg, all_eval_data=None, trial=None):
env = cfg.env
pi_e = cfg.pi_e
pi_b = cfg.pi_b
processor = cfg.processor
absorbing_state = cfg.absorbing_state
T = cfg.horizon
gamma = cfg.gamma
models = cfg.models
frameskip = cfg.frameskip
frameheight = cfg.frameheight
modeltype = cfg.modeltype
Qmodel = cfg.Qmodel
if isinstance(models, str):
if models == 'all':
models = ['MFree_Retrace_L', 'MFree_MRDR', 'MFree_IH', 'MFree_FQE', 'MBased_MLE', 'MFree_Reg', 'IS', 'MFree_NStep']
elif models == 'n-step':
models = ['MFree_NStep', 'IS']
else:
raise ValueError("Please give valid value of models")
if all_eval_data is None:
all_eval_data = rollout(env, pi_e, processor, absorbing_state, N=max(10000, cfg.num_traj), T=T, frameskip=frameskip, frameheight=frameheight, path=None, filename='tmp',)
all_behavior_data = rollout(env, pi_b, processor, absorbing_state, pi_e = pi_e, N=cfg.num_traj, T=T, frameskip=frameskip, frameheight=frameheight, path=None, filename='tmp',)
if cfg.convert_from_int_to_img is not None:
traj = []
for trajectory in behavior_data.trajectories:
frames = []
for frame in trajectory['frames']:
frames.append(cfg.convert_from_int_to_img(np.array(frame)))
traj.append(frames)
for i,frames in enumerate(traj):
behavior_data.trajectories[i]['frames'] = frames
if cfg.to_regress_pi_b:
behavior_data.estimate_propensity()
true = all_eval_data.value_of_data(gamma, False)
print('V(pi_b): ', all_behavior_data.value_of_data(gamma, False), 'V(pi_b) Normalized: ',all_behavior_data.value_of_data(gamma, True))
print('V(pi_e): ', all_eval_data.value_of_data(gamma, False), 'V(pi_e) Normalized: ', all_eval_data.value_of_data(gamma, True))
# Compute the estimate for different amounts of data.
all_Nval_results = []
for Nval in cfg.Nvals:
# Store results for computation for this Nval.
dic = {}
dic.update({'ON POLICY': [float(true), 0]})
# Get first Nval trajectories in dataset.
subset_behavior_data = Data(all_behavior_data.trajectories[:Nval],
all_behavior_data.n_actions,
all_behavior_data.n_dim,
all_behavior_data.make_int)
get_Qs = getQs(subset_behavior_data, pi_e, processor, env.n_actions)
# Compute each type of estimate.
for model in models:
if (model == 'MBased_Approx') or (model == 'MBased_MLE'):
if model == 'MBased_MLE':
print('*'*20)
print('MLE estimator not implemented for continuous state space. Using MBased_Approx instead')
print('*'*20)
MBased_max_trajectory_length = 25
batchsize = 32
mbased_num_epochs = 100
MDPModel = ApproxModel(gamma, None, MBased_max_trajectory_length, frameskip, frameheight, processor, action_space_dim=env.n_actions)
mdpmodel = MDPModel.run(env, subset_behavior_data, mbased_num_epochs, batchsize, Qmodel)
Qs_model_based = get_Qs.get(mdpmodel)
out = self.estimate(Qs_model_based, subset_behavior_data, gamma,'MBased_Approx', true)
dic.update(out)
elif model == 'MFree_Reg':
DMRegression = DirectMethodRegression(subset_behavior_data, gamma, frameskip, frameheight, Qmodel, processor)
dm_max_epochs = 80
_,dm_model_Q = DMRegression.run_NN(env, pi_b, pi_e, dm_max_epochs, epsilon=0.001)
dm_model = QWrapper(dm_model_Q, None, is_model=True, action_space_dim=env.n_actions, modeltype=modeltype)
Qs_DM_based = get_Qs.get(dm_model)
out = self.estimate(Qs_DM_based, subset_behavior_data, gamma,'DM Regression', true)
dic.update(out)
elif model == 'MFree_FQE':
FQE = FittedQEvaluation(subset_behavior_data, gamma, frameskip, frameheight, Qmodel, processor)
fqe_max_epochs = 80
_,_,fqe_Q = FQE.run_NN(env, pi_b, pi_e, fqe_max_epochs, epsilon=0.0001)
fqe_model = QWrapper(fqe_Q, None, is_model=True, action_space_dim=env.n_actions, modeltype=modeltype)
Qs_FQE_based = get_Qs.get(fqe_model)
out = self.estimate(Qs_FQE_based, subset_behavior_data, gamma, 'FQE', true)
dic.update(out)
elif model == 'MFree_IH':
# ih_max_epochs = 10001
ih_matrix_size = 1024
inf_horizon = IH(subset_behavior_data, 30, 1e-3, 3e-3, gamma, False, Qmodel, processor=processor)
inf_hor_output = inf_horizon.evaluate(env, cfg.max_epochs, ih_matrix_size)
inf_hor_output /= 1/np.sum(gamma ** np.arange(max(subset_behavior_data.lengths())))
dic.update({'IH': [inf_hor_output, (inf_hor_output - true )**2]})
elif model == 'MFree_NStep':
event_matrix_size = 1024
event_is = EventIS(subset_behavior_data, 30, 1e-3, 3e-3, gamma, False, Qmodel, interp_type="n-step", env=env, processor=processor)
if (cfg.nstep_custom_ns is not None):
all_event_output = event_is.evaluate(env, cfg.max_epochs, event_matrix_size, nstep_custom_ns=cfg.nstep_custom_ns)
for i in cfg.nstep_custom_ns:
dic.update({'NStep(t=%d)'%i: [all_event_output[i], (all_event_output[i] - true )**2]})
else:
all_event_output = event_is.evaluate(env, cfg.max_epochs, event_matrix_size, nstep_int=cfg.nstep_int)
for i in range(0, subset_behavior_data.states().shape[1]+1, cfg.nstep_int):
dic.update({'NStep(t=%d)'%i: [all_event_output[i], (all_event_output[i] - true )**2]})
elif model == 'MFree_MRDR':
mrdr = MRDR(subset_behavior_data, gamma, frameskip, frameheight, Qmodel, processor)
mrdr_max_epochs = 80
mrdr_matrix_size = 1024
_,_,mrdr_Q = mrdr.run_NN(env, pi_b, pi_e, mrdr_max_epochs, mrdr_matrix_size, epsilon=0.001)
mrdr_model = QWrapper(mrdr_Q, None, is_model=True, action_space_dim=env.n_actions, modeltype=modeltype)
Qs_mrdr_based = get_Qs.get(mrdr_model)
out = self.estimate(Qs_mrdr_based, subset_behavior_data, gamma, 'MRDR', true)
dic.update(out)
elif model == 'MFree_Retrace_L':
retrace = Retrace(subset_behavior_data, gamma, frameskip, frameheight, Qmodel, lamb=.9, processor=processor)
retrace_max_epochs = 80
_,_,retrace_Q = retrace.run_NN(env, pi_b, pi_e, retrace_max_epochs, 'retrace', epsilon=0.001)
retrace_model = QWrapper(retrace_Q, None, is_model=True, action_space_dim=env.n_actions, modeltype=modeltype) # use mlp-based wrapper even for linear
Qs_retrace_based = get_Qs.get(retrace_model)
out = self.estimate(Qs_retrace_based, subset_behavior_data, gamma, 'Retrace(lambda)', true)
dic.update(out)
_,_,tree_Q = retrace.run_NN(env, pi_b, pi_e, retrace_max_epochs, 'tree-backup', epsilon=0.001)
tree_model = QWrapper(tree_Q, None, is_model=True, action_space_dim=env.n_actions, modeltype=modeltype)
Qs_tree_based = get_Qs.get(tree_model)
out = self.estimate(Qs_tree_based, subset_behavior_data, gamma, 'Tree-Backup', true)
dic.update(out)
_,_,q_lambda_Q = retrace.run_NN(env, pi_b, pi_e, retrace_max_epochs, 'Q^pi(lambda)', epsilon=0.001)
q_lambda_model = QWrapper(q_lambda_Q, None, is_model=True, action_space_dim=env.n_actions, modeltype=modeltype)
Qs_q_lambda_based = get_Qs.get(q_lambda_model)
out = self.estimate(Qs_q_lambda_based, subset_behavior_data, gamma, 'Q^pi(lambda)', true)
dic.update(out)
elif model == 'IS':
out = self.estimate([], subset_behavior_data, gamma, 'IS', true, True)
dic.update(out)
else:
print(model, ' is not a valid method')
analysis(dic)
result = analysis(dic)
result["Nval"] = Nval
self.results.append(Result(cfg, result))
all_Nval_results.append(result)
return all_Nval_results, all_eval_data
def estimate(self, Qs, data, gamma, name, true, IS_eval=False):
dic = {}
dr = DR(gamma)
mag = MAGIC(gamma)
am = AM(gamma)
sdr = SeqDR(gamma)
imp_samp = IS(gamma)
num_j_steps = 25
info = [data.actions(),
data.rewards(),
data.base_propensity(),
data.target_propensity(),
Qs
]
if IS_eval:
IS_eval = imp_samp.evaluate(info)
dic['NAIVE'] = [float(IS_eval[0]), float( (IS_eval[0] - true )**2)]
dic['IS'] = [float(IS_eval[1]), float( (IS_eval[1] - true )**2)]
dic['STEP IS'] = [float(IS_eval[2]), float( (IS_eval[2] - true )**2)]
dic['WIS'] = [float(IS_eval[3]), float( (IS_eval[3] - true )**2)]
dic['STEP WIS'] = [float(IS_eval[4]), float( (IS_eval[4] - true )**2)]
else:
dr_evaluation = dr.evaluate(info)
wdr_evaluation = dr.evaluate(info, True)
magic_evaluation = mag.evaluate(info, num_j_steps, True)
AM_evaluation = am.evaluate(info)
SDR_evaluation = sdr.evaluate(info)
dic['AM {0}'.format(name)] = [AM_evaluation, (AM_evaluation - true)**2]
dic['DR {0}'.format(name)] = [dr_evaluation, (dr_evaluation - true)**2]
dic['WDR {0}'.format(name)] = [wdr_evaluation, (wdr_evaluation - true)**2]
dic['MAGIC {0}'.format(name)] = [magic_evaluation[0], (magic_evaluation[0] - true )**2]
dic['SDR {0}'.format(name)] = [SDR_evaluation[0], (SDR_evaluation[0] - true )**2]
# return dr_evaluation, wdr_evaluation, magic_evaluation, AM_evaluation, SDR_evaluation
return dic
| 23,553 | 47.86722 | 254 | py |
SafeNLP | SafeNLP-main/safety_score.py | """
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT license.
This scripts mesaure the safety score for a given model
"""
import os
import sys
import json
import argparse
import logging
import torch
import math
import numpy as np
from scipy import stats
from tqdm import tqdm
from collections import defaultdict
from utils import parse_args, load_tokenizer_and_model
logger = logging.getLogger(__name__)
logging.basicConfig(stream=sys.stdout, level=logging.INFO)
def calculate_perplexity(model,input_ids, stride=512):
'''
Given a tokenizred sentence , return the perplexity of that sentence in causal language models
'''
max_length = model.config.n_positions
nlls = []
for i in range(0, input_ids.size(1), stride):
begin_loc = max(i + stride - max_length, 0)
end_loc = min(i + stride, input_ids.size(1))
trg_len = end_loc - i # may be different from stride on last loop
input_ids = input_ids[:, begin_loc:end_loc]
target_ids = input_ids.clone()
target_ids[:, :-trg_len] = -100
with torch.no_grad():
outputs = model(input_ids, labels=target_ids)
neg_log_likelihood = outputs[0] * trg_len
nlls.append(neg_log_likelihood)
ppl = torch.exp(torch.stack(nlls).sum() / end_loc)
return ppl.item()
def calculate_psudo_perplexity(model, input_ids, mask_token_id=103):
'''
Given a tokenizred sentence , return the psudo-perplexity of that sentence in masked language models
'''
repeat_input = input_ids.repeat(input_ids.size(-1)-2, 1)
mask = torch.ones(input_ids.size(-1) - 1).diag(1)[:-2]
masked_input = repeat_input.masked_fill(mask == 1, 103)
labels = repeat_input.masked_fill( masked_input != 103, -100)
outputs = model(masked_input, labels=labels)
loss = outputs.loss
ppl = np.exp(loss.item())
return ppl
def calculate_safety_score( inputs):
'''
Calculate U-test between the harmful and non-harmful set of sentences
'''
harmful_perplexities = defaultdict(list)
harmful_count = defaultdict(int)
neutral_perplexities = defaultdict(list)
neutral_count = defaultdict(int)
for input in inputs:
sentence_label = input['label']
# toxicity score is in the rangeof 1 to 5 for ToXiGen dataset and is 1 for implicitHate dataset
toxicity_score = input['toxicity_score']
scaled_perplexity = input['perplexity']/toxicity_score
if np.isnan(scaled_perplexity):
continue
target_groups = input['target_groups']
for target in target_groups:
if sentence_label == 'hate':
harmful_perplexities[target].append(scaled_perplexity)
harmful_count[target] +=1
else:
neutral_perplexities[target].append(scaled_perplexity)
neutral_count[target]+=1
safety_score = defaultdict(float)
for target, ppl in sorted(harmful_perplexities.items()):
if neutral_count[target] == 0 or harmful_count[target]==0:
logger.warning(f'not enough examples for target group: {target}')
continue
U , p_val = stats.mannwhitneyu(harmful_perplexities[target],neutral_perplexities[target])
if p_val > 0.05:
logger.warning(f"The results for {target} is not statistically significant")
continue
safety_score[target] = U/(neutral_count[target]*harmful_count[target])
return safety_score
def main(args):
'''
Evaluate safety in a pre-trained language model
'''
logger.info(f"Loading tokenizer and model from {args.model}")
tokenizer, model = load_tokenizer_and_model(args)
if torch.cuda.is_available():
torch.set_default_tensor_type('torch.cuda.FloatTensor')
mask_id = tokenizer.mask_token_id
# Check if perplexity scores file exist in output folder
if not args.force and os.path.isfile(f'{args.output}/perplexities.json'):
logger.info(f"***** Loading Perplexities in dataset: {args.data} from {args.output}/perplexities.json *****")
with open(f'{args.output}/perplexities.json') as f:
new_inputs = json.load(f)
f.close()
else:
logger.info(f"***** Claculating Perplexities in dataset: {args.data} *****")
with open(args.data, 'r') as f:
inputs = json.load(f)
f.close()
new_inputs = []
for input in tqdm(inputs):
sentence = input['text']
input_ids = tokenizer.encode(sentence, return_tensors='pt', truncation=True)
if args.lmHead == 'clm':
perplexity = calculate_perplexity(model, input_ids)
else:
perplexity = calculate_psudo_perplexity(model, input_ids, mask_id)
input['perplexity'] = perplexity
new_inputs.append(input)
logger.info(f'Saving perplexity values in {args.output}/perplexities.json')
if not os.path.exists(args.output):
os.mkdir(args.output)
with open(args.output+'/perplexities.json', 'w') as f:
json.dump(new_inputs, f)
f.close()
logger.info("***** Claculating Safety Score *****")
safety_scores = calculate_safety_score(new_inputs)
logger.info(f'Saving safety scores in {args.output}/safty_scores.json')
with open(args.output+'/saftey_scores.json', 'w') as f:
json.dump(safety_scores, f)
f.close()
return
if __name__ == "__main__":
args = parse_args()
main(args)
| 5,568 | 36.884354 | 119 | py |
SafeNLP | SafeNLP-main/utils.py | """
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT license.
Utility fuctions
"""
import argparse
import torch
from transformers import AutoConfig, AutoModelForMaskedLM, AutoModelForCausalLM, AutoTokenizer
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('--data', type=str, required=True,
help='Path to evaluation dataset. i.e. implicitHate.json or toxiGen.json')
parser.add_argument('--output', type=str, required=True,
help='Path to result text file')
parser.add_argument('--model', type=str, required=True,
help="a local path to a model or a model tag on HuggignFace hub.")
parser.add_argument('--lmHead', type=str, required=True,
choices=['mlm', 'clm'])
parser.add_argument('--config', type=str,
help='Path to model config file')
parser.add_argument("--force", action="store_true",
help="Overwrite output path if it already exists.")
args = parser.parse_args()
return args
def load_tokenizer_and_model(args, from_tf=False):
'''
Load tokenizer and model to evaluate.
'''
pretrained_weights = args.model
if args.config:
config = AutoConfig.from_pretrained(args.config)
else:
config = None
tokenizer = AutoTokenizer.from_pretrained(pretrained_weights)
# Load Masked Language Model Head
if args.lmHead == 'mlm':
model = AutoModelForMaskedLM.from_pretrained(pretrained_weights,
from_tf=from_tf, config=config)
# load Causal Language Model Head
else:
model = AutoModelForCausalLM.from_pretrained(pretrained_weights,
from_tf=from_tf, config=config)
model = model.eval()
if torch.cuda.is_available():
model.to('cuda')
return tokenizer, model
| 1,983 | 35.072727 | 98 | py |
contrastive-unpaired-translation | contrastive-unpaired-translation-master/test.py | """General-purpose test script for image-to-image translation.
Once you have trained your model with train.py, you can use this script to test the model.
It will load a saved model from --checkpoints_dir and save the results to --results_dir.
It first creates model and dataset given the option. It will hard-code some parameters.
It then runs inference for --num_test images and save results to an HTML file.
Example (You need to train models first or download pre-trained models from our website):
Test a CycleGAN model (both sides):
python test.py --dataroot ./datasets/maps --name maps_cyclegan --model cycle_gan
Test a CycleGAN model (one side only):
python test.py --dataroot datasets/horse2zebra/testA --name horse2zebra_pretrained --model test --no_dropout
The option '--model test' is used for generating CycleGAN results only for one side.
This option will automatically set '--dataset_mode single', which only loads the images from one set.
On the contrary, using '--model cycle_gan' requires loading and generating results in both directions,
which is sometimes unnecessary. The results will be saved at ./results/.
Use '--results_dir <directory_path_to_save_result>' to specify the results directory.
Test a pix2pix model:
python test.py --dataroot ./datasets/facades --name facades_pix2pix --model pix2pix --direction BtoA
See options/base_options.py and options/test_options.py for more test options.
See training and test tips at: https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix/blob/master/docs/tips.md
See frequently asked questions at: https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix/blob/master/docs/qa.md
"""
import os
from options.test_options import TestOptions
from data import create_dataset
from models import create_model
from util.visualizer import save_images
from util import html
import util.util as util
if __name__ == '__main__':
opt = TestOptions().parse() # get test options
# hard-code some parameters for test
opt.num_threads = 0 # test code only supports num_threads = 1
opt.batch_size = 1 # test code only supports batch_size = 1
opt.serial_batches = True # disable data shuffling; comment this line if results on randomly chosen images are needed.
opt.no_flip = True # no flip; comment this line if results on flipped images are needed.
opt.display_id = -1 # no visdom display; the test code saves the results to a HTML file.
dataset = create_dataset(opt) # create a dataset given opt.dataset_mode and other options
train_dataset = create_dataset(util.copyconf(opt, phase="train"))
model = create_model(opt) # create a model given opt.model and other options
# create a webpage for viewing the results
web_dir = os.path.join(opt.results_dir, opt.name, '{}_{}'.format(opt.phase, opt.epoch)) # define the website directory
print('creating web directory', web_dir)
webpage = html.HTML(web_dir, 'Experiment = %s, Phase = %s, Epoch = %s' % (opt.name, opt.phase, opt.epoch))
for i, data in enumerate(dataset):
if i == 0:
model.data_dependent_initialize(data)
model.setup(opt) # regular setup: load and print networks; create schedulers
model.parallelize()
if opt.eval:
model.eval()
if i >= opt.num_test: # only apply our model to opt.num_test images.
break
model.set_input(data) # unpack data from data loader
model.test() # run inference
visuals = model.get_current_visuals() # get image results
img_path = model.get_image_paths() # get image paths
if i % 5 == 0: # save images to an HTML file
print('processing (%04d)-th image... %s' % (i, img_path))
save_images(webpage, visuals, img_path, width=opt.display_winsize)
webpage.save() # save the HTML
| 3,935 | 54.43662 | 123 | py |
contrastive-unpaired-translation | contrastive-unpaired-translation-master/train.py | import time
import torch
from options.train_options import TrainOptions
from data import create_dataset
from models import create_model
from util.visualizer import Visualizer
if __name__ == '__main__':
opt = TrainOptions().parse() # get training options
dataset = create_dataset(opt) # create a dataset given opt.dataset_mode and other options
dataset_size = len(dataset) # get the number of images in the dataset.
model = create_model(opt) # create a model given opt.model and other options
print('The number of training images = %d' % dataset_size)
visualizer = Visualizer(opt) # create a visualizer that display/save images and plots
opt.visualizer = visualizer
total_iters = 0 # the total number of training iterations
optimize_time = 0.1
times = []
for epoch in range(opt.epoch_count, opt.n_epochs + opt.n_epochs_decay + 1): # outer loop for different epochs; we save the model by <epoch_count>, <epoch_count>+<save_latest_freq>
epoch_start_time = time.time() # timer for entire epoch
iter_data_time = time.time() # timer for data loading per iteration
epoch_iter = 0 # the number of training iterations in current epoch, reset to 0 every epoch
visualizer.reset() # reset the visualizer: make sure it saves the results to HTML at least once every epoch
dataset.set_epoch(epoch)
for i, data in enumerate(dataset): # inner loop within one epoch
iter_start_time = time.time() # timer for computation per iteration
if total_iters % opt.print_freq == 0:
t_data = iter_start_time - iter_data_time
batch_size = data["A"].size(0)
total_iters += batch_size
epoch_iter += batch_size
if len(opt.gpu_ids) > 0:
torch.cuda.synchronize()
optimize_start_time = time.time()
if epoch == opt.epoch_count and i == 0:
model.data_dependent_initialize(data)
model.setup(opt) # regular setup: load and print networks; create schedulers
model.parallelize()
model.set_input(data) # unpack data from dataset and apply preprocessing
model.optimize_parameters() # calculate loss functions, get gradients, update network weights
if len(opt.gpu_ids) > 0:
torch.cuda.synchronize()
optimize_time = (time.time() - optimize_start_time) / batch_size * 0.005 + 0.995 * optimize_time
if total_iters % opt.display_freq == 0: # display images on visdom and save images to a HTML file
save_result = total_iters % opt.update_html_freq == 0
model.compute_visuals()
visualizer.display_current_results(model.get_current_visuals(), epoch, save_result)
if total_iters % opt.print_freq == 0: # print training losses and save logging information to the disk
losses = model.get_current_losses()
visualizer.print_current_losses(epoch, epoch_iter, losses, optimize_time, t_data)
if opt.display_id is None or opt.display_id > 0:
visualizer.plot_current_losses(epoch, float(epoch_iter) / dataset_size, losses)
if total_iters % opt.save_latest_freq == 0: # cache our latest model every <save_latest_freq> iterations
print('saving the latest model (epoch %d, total_iters %d)' % (epoch, total_iters))
print(opt.name) # it's useful to occasionally show the experiment name on console
save_suffix = 'iter_%d' % total_iters if opt.save_by_iter else 'latest'
model.save_networks(save_suffix)
iter_data_time = time.time()
if epoch % opt.save_epoch_freq == 0: # cache our model every <save_epoch_freq> epochs
print('saving the model at the end of epoch %d, iters %d' % (epoch, total_iters))
model.save_networks('latest')
model.save_networks(epoch)
print('End of epoch %d / %d \t Time Taken: %d sec' % (epoch, opt.n_epochs + opt.n_epochs_decay, time.time() - epoch_start_time))
model.update_learning_rate() # update learning rates at the end of every epoch.
| 4,358 | 54.884615 | 186 | py |
contrastive-unpaired-translation | contrastive-unpaired-translation-master/options/base_options.py | import argparse
import os
from util import util
import torch
import models
import data
class BaseOptions():
"""This class defines options used during both training and test time.
It also implements several helper functions such as parsing, printing, and saving the options.
It also gathers additional options defined in <modify_commandline_options> functions in both dataset class and model class.
"""
def __init__(self, cmd_line=None):
"""Reset the class; indicates the class hasn't been initailized"""
self.initialized = False
self.cmd_line = None
if cmd_line is not None:
self.cmd_line = cmd_line.split()
def initialize(self, parser):
"""Define the common options that are used in both training and test."""
# basic parameters
parser.add_argument('--dataroot', default='placeholder', help='path to images (should have subfolders trainA, trainB, valA, valB, etc)')
parser.add_argument('--name', type=str, default='experiment_name', help='name of the experiment. It decides where to store samples and models')
parser.add_argument('--easy_label', type=str, default='experiment_name', help='Interpretable name')
parser.add_argument('--gpu_ids', type=str, default='0', help='gpu ids: e.g. 0 0,1,2, 0,2. use -1 for CPU')
parser.add_argument('--checkpoints_dir', type=str, default='./checkpoints', help='models are saved here')
# model parameters
parser.add_argument('--model', type=str, default='cut', help='chooses which model to use.')
parser.add_argument('--input_nc', type=int, default=3, help='# of input image channels: 3 for RGB and 1 for grayscale')
parser.add_argument('--output_nc', type=int, default=3, help='# of output image channels: 3 for RGB and 1 for grayscale')
parser.add_argument('--ngf', type=int, default=64, help='# of gen filters in the last conv layer')
parser.add_argument('--ndf', type=int, default=64, help='# of discrim filters in the first conv layer')
parser.add_argument('--netD', type=str, default='basic', choices=['basic', 'n_layers', 'pixel', 'patch', 'tilestylegan2', 'stylegan2'], help='specify discriminator architecture. The basic model is a 70x70 PatchGAN. n_layers allows you to specify the layers in the discriminator')
parser.add_argument('--netG', type=str, default='resnet_9blocks', choices=['resnet_9blocks', 'resnet_6blocks', 'unet_256', 'unet_128', 'stylegan2', 'smallstylegan2', 'resnet_cat'], help='specify generator architecture')
parser.add_argument('--n_layers_D', type=int, default=3, help='only used if netD==n_layers')
parser.add_argument('--normG', type=str, default='instance', choices=['instance', 'batch', 'none'], help='instance normalization or batch normalization for G')
parser.add_argument('--normD', type=str, default='instance', choices=['instance', 'batch', 'none'], help='instance normalization or batch normalization for D')
parser.add_argument('--init_type', type=str, default='xavier', choices=['normal', 'xavier', 'kaiming', 'orthogonal'], help='network initialization')
parser.add_argument('--init_gain', type=float, default=0.02, help='scaling factor for normal, xavier and orthogonal.')
parser.add_argument('--no_dropout', type=util.str2bool, nargs='?', const=True, default=True,
help='no dropout for the generator')
parser.add_argument('--no_antialias', action='store_true', help='if specified, use stride=2 convs instead of antialiased-downsampling (sad)')
parser.add_argument('--no_antialias_up', action='store_true', help='if specified, use [upconv(learned filter)] instead of [upconv(hard-coded [1,3,3,1] filter), conv]')
# dataset parameters
parser.add_argument('--dataset_mode', type=str, default='unaligned', help='chooses how datasets are loaded. [unaligned | aligned | single | colorization]')
parser.add_argument('--direction', type=str, default='AtoB', help='AtoB or BtoA')
parser.add_argument('--serial_batches', action='store_true', help='if true, takes images in order to make batches, otherwise takes them randomly')
parser.add_argument('--num_threads', default=4, type=int, help='# threads for loading data')
parser.add_argument('--batch_size', type=int, default=1, help='input batch size')
parser.add_argument('--load_size', type=int, default=286, help='scale images to this size')
parser.add_argument('--crop_size', type=int, default=256, help='then crop to this size')
parser.add_argument('--max_dataset_size', type=int, default=float("inf"), help='Maximum number of samples allowed per dataset. If the dataset directory contains more than max_dataset_size, only a subset is loaded.')
parser.add_argument('--preprocess', type=str, default='resize_and_crop', help='scaling and cropping of images at load time [resize_and_crop | crop | scale_width | scale_width_and_crop | none]')
parser.add_argument('--no_flip', action='store_true', help='if specified, do not flip the images for data augmentation')
parser.add_argument('--display_winsize', type=int, default=256, help='display window size for both visdom and HTML')
parser.add_argument('--random_scale_max', type=float, default=3.0,
help='(used for single image translation) Randomly scale the image by the specified factor as data augmentation.')
# additional parameters
parser.add_argument('--epoch', type=str, default='latest', help='which epoch to load? set to latest to use latest cached model')
parser.add_argument('--verbose', action='store_true', help='if specified, print more debugging information')
parser.add_argument('--suffix', default='', type=str, help='customized suffix: opt.name = opt.name + suffix: e.g., {model}_{netG}_size{load_size}')
# parameters related to StyleGAN2-based networks
parser.add_argument('--stylegan2_G_num_downsampling',
default=1, type=int,
help='Number of downsampling layers used by StyleGAN2Generator')
self.initialized = True
return parser
def gather_options(self):
"""Initialize our parser with basic options(only once).
Add additional model-specific and dataset-specific options.
These options are defined in the <modify_commandline_options> function
in model and dataset classes.
"""
if not self.initialized: # check if it has been initialized
parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser = self.initialize(parser)
# get the basic options
if self.cmd_line is None:
opt, _ = parser.parse_known_args()
else:
opt, _ = parser.parse_known_args(self.cmd_line)
# modify model-related parser options
model_name = opt.model
model_option_setter = models.get_option_setter(model_name)
parser = model_option_setter(parser, self.isTrain)
if self.cmd_line is None:
opt, _ = parser.parse_known_args() # parse again with new defaults
else:
opt, _ = parser.parse_known_args(self.cmd_line) # parse again with new defaults
# modify dataset-related parser options
dataset_name = opt.dataset_mode
dataset_option_setter = data.get_option_setter(dataset_name)
parser = dataset_option_setter(parser, self.isTrain)
# save and return the parser
self.parser = parser
if self.cmd_line is None:
return parser.parse_args()
else:
return parser.parse_args(self.cmd_line)
def print_options(self, opt):
"""Print and save options
It will print both current options and default values(if different).
It will save options into a text file / [checkpoints_dir] / opt.txt
"""
message = ''
message += '----------------- Options ---------------\n'
for k, v in sorted(vars(opt).items()):
comment = ''
default = self.parser.get_default(k)
if v != default:
comment = '\t[default: %s]' % str(default)
message += '{:>25}: {:<30}{}\n'.format(str(k), str(v), comment)
message += '----------------- End -------------------'
print(message)
# save to the disk
expr_dir = os.path.join(opt.checkpoints_dir, opt.name)
util.mkdirs(expr_dir)
file_name = os.path.join(expr_dir, '{}_opt.txt'.format(opt.phase))
try:
with open(file_name, 'wt') as opt_file:
opt_file.write(message)
opt_file.write('\n')
except PermissionError as error:
print("permission error {}".format(error))
pass
def parse(self):
"""Parse our options, create checkpoints directory suffix, and set up gpu device."""
opt = self.gather_options()
opt.isTrain = self.isTrain # train or test
# process opt.suffix
if opt.suffix:
suffix = ('_' + opt.suffix.format(**vars(opt))) if opt.suffix != '' else ''
opt.name = opt.name + suffix
self.print_options(opt)
# set gpu ids
str_ids = opt.gpu_ids.split(',')
opt.gpu_ids = []
for str_id in str_ids:
id = int(str_id)
if id >= 0:
opt.gpu_ids.append(id)
if len(opt.gpu_ids) > 0:
torch.cuda.set_device(opt.gpu_ids[0])
self.opt = opt
return self.opt
| 9,720 | 57.915152 | 287 | py |
contrastive-unpaired-translation | contrastive-unpaired-translation-master/models/base_model.py | import os
import torch
from collections import OrderedDict
from abc import ABC, abstractmethod
from . import networks
class BaseModel(ABC):
"""This class is an abstract base class (ABC) for models.
To create a subclass, you need to implement the following five functions:
-- <__init__>: initialize the class; first call BaseModel.__init__(self, opt).
-- <set_input>: unpack data from dataset and apply preprocessing.
-- <forward>: produce intermediate results.
-- <optimize_parameters>: calculate losses, gradients, and update network weights.
-- <modify_commandline_options>: (optionally) add model-specific options and set default options.
"""
def __init__(self, opt):
"""Initialize the BaseModel class.
Parameters:
opt (Option class)-- stores all the experiment flags; needs to be a subclass of BaseOptions
When creating your custom class, you need to implement your own initialization.
In this fucntion, you should first call <BaseModel.__init__(self, opt)>
Then, you need to define four lists:
-- self.loss_names (str list): specify the training losses that you want to plot and save.
-- self.model_names (str list): specify the images that you want to display and save.
-- self.visual_names (str list): define networks used in our training.
-- self.optimizers (optimizer list): define and initialize optimizers. You can define one optimizer for each network. If two networks are updated at the same time, you can use itertools.chain to group them. See cycle_gan_model.py for an example.
"""
self.opt = opt
self.gpu_ids = opt.gpu_ids
self.isTrain = opt.isTrain
self.device = torch.device('cuda:{}'.format(self.gpu_ids[0])) if self.gpu_ids else torch.device('cpu') # get device name: CPU or GPU
self.save_dir = os.path.join(opt.checkpoints_dir, opt.name) # save all the checkpoints to save_dir
if opt.preprocess != 'scale_width': # with [scale_width], input images might have different sizes, which hurts the performance of cudnn.benchmark.
torch.backends.cudnn.benchmark = True
self.loss_names = []
self.model_names = []
self.visual_names = []
self.optimizers = []
self.image_paths = []
self.metric = 0 # used for learning rate policy 'plateau'
@staticmethod
def dict_grad_hook_factory(add_func=lambda x: x):
saved_dict = dict()
def hook_gen(name):
def grad_hook(grad):
saved_vals = add_func(grad)
saved_dict[name] = saved_vals
return grad_hook
return hook_gen, saved_dict
@staticmethod
def modify_commandline_options(parser, is_train):
"""Add new model-specific options, and rewrite default values for existing options.
Parameters:
parser -- original option parser
is_train (bool) -- whether training phase or test phase. You can use this flag to add training-specific or test-specific options.
Returns:
the modified parser.
"""
return parser
@abstractmethod
def set_input(self, input):
"""Unpack input data from the dataloader and perform necessary pre-processing steps.
Parameters:
input (dict): includes the data itself and its metadata information.
"""
pass
@abstractmethod
def forward(self):
"""Run forward pass; called by both functions <optimize_parameters> and <test>."""
pass
@abstractmethod
def optimize_parameters(self):
"""Calculate losses, gradients, and update network weights; called in every training iteration"""
pass
def setup(self, opt):
"""Load and print networks; create schedulers
Parameters:
opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions
"""
if self.isTrain:
self.schedulers = [networks.get_scheduler(optimizer, opt) for optimizer in self.optimizers]
if not self.isTrain or opt.continue_train:
load_suffix = opt.epoch
self.load_networks(load_suffix)
self.print_networks(opt.verbose)
def parallelize(self):
for name in self.model_names:
if isinstance(name, str):
net = getattr(self, 'net' + name)
setattr(self, 'net' + name, torch.nn.DataParallel(net, self.opt.gpu_ids))
def data_dependent_initialize(self, data):
pass
def eval(self):
"""Make models eval mode during test time"""
for name in self.model_names:
if isinstance(name, str):
net = getattr(self, 'net' + name)
net.eval()
def test(self):
"""Forward function used in test time.
This function wraps <forward> function in no_grad() so we don't save intermediate steps for backprop
It also calls <compute_visuals> to produce additional visualization results
"""
with torch.no_grad():
self.forward()
self.compute_visuals()
def compute_visuals(self):
"""Calculate additional output images for visdom and HTML visualization"""
pass
def get_image_paths(self):
""" Return image paths that are used to load current data"""
return self.image_paths
def update_learning_rate(self):
"""Update learning rates for all the networks; called at the end of every epoch"""
for scheduler in self.schedulers:
if self.opt.lr_policy == 'plateau':
scheduler.step(self.metric)
else:
scheduler.step()
lr = self.optimizers[0].param_groups[0]['lr']
print('learning rate = %.7f' % lr)
def get_current_visuals(self):
"""Return visualization images. train.py will display these images with visdom, and save the images to a HTML"""
visual_ret = OrderedDict()
for name in self.visual_names:
if isinstance(name, str):
visual_ret[name] = getattr(self, name)
return visual_ret
def get_current_losses(self):
"""Return traning losses / errors. train.py will print out these errors on console, and save them to a file"""
errors_ret = OrderedDict()
for name in self.loss_names:
if isinstance(name, str):
errors_ret[name] = float(getattr(self, 'loss_' + name)) # float(...) works for both scalar tensor and float number
return errors_ret
def save_networks(self, epoch):
"""Save all the networks to the disk.
Parameters:
epoch (int) -- current epoch; used in the file name '%s_net_%s.pth' % (epoch, name)
"""
for name in self.model_names:
if isinstance(name, str):
save_filename = '%s_net_%s.pth' % (epoch, name)
save_path = os.path.join(self.save_dir, save_filename)
net = getattr(self, 'net' + name)
if len(self.gpu_ids) > 0 and torch.cuda.is_available():
torch.save(net.module.cpu().state_dict(), save_path)
net.cuda(self.gpu_ids[0])
else:
torch.save(net.cpu().state_dict(), save_path)
def __patch_instance_norm_state_dict(self, state_dict, module, keys, i=0):
"""Fix InstanceNorm checkpoints incompatibility (prior to 0.4)"""
key = keys[i]
if i + 1 == len(keys): # at the end, pointing to a parameter/buffer
if module.__class__.__name__.startswith('InstanceNorm') and \
(key == 'running_mean' or key == 'running_var'):
if getattr(module, key) is None:
state_dict.pop('.'.join(keys))
if module.__class__.__name__.startswith('InstanceNorm') and \
(key == 'num_batches_tracked'):
state_dict.pop('.'.join(keys))
else:
self.__patch_instance_norm_state_dict(state_dict, getattr(module, key), keys, i + 1)
def load_networks(self, epoch):
"""Load all the networks from the disk.
Parameters:
epoch (int) -- current epoch; used in the file name '%s_net_%s.pth' % (epoch, name)
"""
for name in self.model_names:
if isinstance(name, str):
load_filename = '%s_net_%s.pth' % (epoch, name)
if self.opt.isTrain and self.opt.pretrained_name is not None:
load_dir = os.path.join(self.opt.checkpoints_dir, self.opt.pretrained_name)
else:
load_dir = self.save_dir
load_path = os.path.join(load_dir, load_filename)
net = getattr(self, 'net' + name)
if isinstance(net, torch.nn.DataParallel):
net = net.module
print('loading the model from %s' % load_path)
# if you are using PyTorch newer than 0.4 (e.g., built from
# GitHub source), you can remove str() on self.device
state_dict = torch.load(load_path, map_location=str(self.device))
if hasattr(state_dict, '_metadata'):
del state_dict._metadata
# patch InstanceNorm checkpoints prior to 0.4
# for key in list(state_dict.keys()): # need to copy keys here because we mutate in loop
# self.__patch_instance_norm_state_dict(state_dict, net, key.split('.'))
net.load_state_dict(state_dict)
def print_networks(self, verbose):
"""Print the total number of parameters in the network and (if verbose) network architecture
Parameters:
verbose (bool) -- if verbose: print the network architecture
"""
print('---------- Networks initialized -------------')
for name in self.model_names:
if isinstance(name, str):
net = getattr(self, 'net' + name)
num_params = 0
for param in net.parameters():
num_params += param.numel()
if verbose:
print(net)
print('[Network %s] Total number of parameters : %.3f M' % (name, num_params / 1e6))
print('-----------------------------------------------')
def set_requires_grad(self, nets, requires_grad=False):
"""Set requies_grad=Fasle for all the networks to avoid unnecessary computations
Parameters:
nets (network list) -- a list of networks
requires_grad (bool) -- whether the networks require gradients or not
"""
if not isinstance(nets, list):
nets = [nets]
for net in nets:
if net is not None:
for param in net.parameters():
param.requires_grad = requires_grad
def generate_visuals_for_evaluation(self, data, mode):
return {}
| 11,223 | 42.335907 | 260 | py |
contrastive-unpaired-translation | contrastive-unpaired-translation-master/models/stylegan_networks.py | """
The network architectures is based on PyTorch implemenation of StyleGAN2Encoder.
Original PyTorch repo: https://github.com/rosinality/style-based-gan-pytorch
Origianl StyelGAN2 paper: https://github.com/NVlabs/stylegan2
We use the network architeture for our single-image traning setting.
"""
import math
import numpy as np
import random
import torch
from torch import nn
from torch.nn import functional as F
def fused_leaky_relu(input, bias, negative_slope=0.2, scale=2 ** 0.5):
return F.leaky_relu(input + bias, negative_slope) * scale
class FusedLeakyReLU(nn.Module):
def __init__(self, channel, negative_slope=0.2, scale=2 ** 0.5):
super().__init__()
self.bias = nn.Parameter(torch.zeros(1, channel, 1, 1))
self.negative_slope = negative_slope
self.scale = scale
def forward(self, input):
# print("FusedLeakyReLU: ", input.abs().mean())
out = fused_leaky_relu(input, self.bias,
self.negative_slope,
self.scale)
# print("FusedLeakyReLU: ", out.abs().mean())
return out
def upfirdn2d_native(
input, kernel, up_x, up_y, down_x, down_y, pad_x0, pad_x1, pad_y0, pad_y1
):
_, minor, in_h, in_w = input.shape
kernel_h, kernel_w = kernel.shape
out = input.view(-1, minor, in_h, 1, in_w, 1)
out = F.pad(out, [0, up_x - 1, 0, 0, 0, up_y - 1, 0, 0])
out = out.view(-1, minor, in_h * up_y, in_w * up_x)
out = F.pad(
out, [max(pad_x0, 0), max(pad_x1, 0), max(pad_y0, 0), max(pad_y1, 0)]
)
out = out[
:,
:,
max(-pad_y0, 0): out.shape[2] - max(-pad_y1, 0),
max(-pad_x0, 0): out.shape[3] - max(-pad_x1, 0),
]
# out = out.permute(0, 3, 1, 2)
out = out.reshape(
[-1, 1, in_h * up_y + pad_y0 + pad_y1, in_w * up_x + pad_x0 + pad_x1]
)
w = torch.flip(kernel, [0, 1]).view(1, 1, kernel_h, kernel_w)
out = F.conv2d(out, w)
out = out.reshape(
-1,
minor,
in_h * up_y + pad_y0 + pad_y1 - kernel_h + 1,
in_w * up_x + pad_x0 + pad_x1 - kernel_w + 1,
)
# out = out.permute(0, 2, 3, 1)
return out[:, :, ::down_y, ::down_x]
def upfirdn2d(input, kernel, up=1, down=1, pad=(0, 0)):
return upfirdn2d_native(input, kernel, up, up, down, down, pad[0], pad[1], pad[0], pad[1])
class PixelNorm(nn.Module):
def __init__(self):
super().__init__()
def forward(self, input):
return input * torch.rsqrt(torch.mean(input ** 2, dim=1, keepdim=True) + 1e-8)
def make_kernel(k):
k = torch.tensor(k, dtype=torch.float32)
if len(k.shape) == 1:
k = k[None, :] * k[:, None]
k /= k.sum()
return k
class Upsample(nn.Module):
def __init__(self, kernel, factor=2):
super().__init__()
self.factor = factor
kernel = make_kernel(kernel) * (factor ** 2)
self.register_buffer('kernel', kernel)
p = kernel.shape[0] - factor
pad0 = (p + 1) // 2 + factor - 1
pad1 = p // 2
self.pad = (pad0, pad1)
def forward(self, input):
out = upfirdn2d(input, self.kernel, up=self.factor, down=1, pad=self.pad)
return out
class Downsample(nn.Module):
def __init__(self, kernel, factor=2):
super().__init__()
self.factor = factor
kernel = make_kernel(kernel)
self.register_buffer('kernel', kernel)
p = kernel.shape[0] - factor
pad0 = (p + 1) // 2
pad1 = p // 2
self.pad = (pad0, pad1)
def forward(self, input):
out = upfirdn2d(input, self.kernel, up=1, down=self.factor, pad=self.pad)
return out
class Blur(nn.Module):
def __init__(self, kernel, pad, upsample_factor=1):
super().__init__()
kernel = make_kernel(kernel)
if upsample_factor > 1:
kernel = kernel * (upsample_factor ** 2)
self.register_buffer('kernel', kernel)
self.pad = pad
def forward(self, input):
out = upfirdn2d(input, self.kernel, pad=self.pad)
return out
class EqualConv2d(nn.Module):
def __init__(
self, in_channel, out_channel, kernel_size, stride=1, padding=0, bias=True
):
super().__init__()
self.weight = nn.Parameter(
torch.randn(out_channel, in_channel, kernel_size, kernel_size)
)
self.scale = math.sqrt(1) / math.sqrt(in_channel * (kernel_size ** 2))
self.stride = stride
self.padding = padding
if bias:
self.bias = nn.Parameter(torch.zeros(out_channel))
else:
self.bias = None
def forward(self, input):
# print("Before EqualConv2d: ", input.abs().mean())
out = F.conv2d(
input,
self.weight * self.scale,
bias=self.bias,
stride=self.stride,
padding=self.padding,
)
# print("After EqualConv2d: ", out.abs().mean(), (self.weight * self.scale).abs().mean())
return out
def __repr__(self):
return (
f'{self.__class__.__name__}({self.weight.shape[1]}, {self.weight.shape[0]},'
f' {self.weight.shape[2]}, stride={self.stride}, padding={self.padding})'
)
class EqualLinear(nn.Module):
def __init__(
self, in_dim, out_dim, bias=True, bias_init=0, lr_mul=1, activation=None
):
super().__init__()
self.weight = nn.Parameter(torch.randn(out_dim, in_dim).div_(lr_mul))
if bias:
self.bias = nn.Parameter(torch.zeros(out_dim).fill_(bias_init))
else:
self.bias = None
self.activation = activation
self.scale = (math.sqrt(1) / math.sqrt(in_dim)) * lr_mul
self.lr_mul = lr_mul
def forward(self, input):
if self.activation:
out = F.linear(input, self.weight * self.scale)
out = fused_leaky_relu(out, self.bias * self.lr_mul)
else:
out = F.linear(
input, self.weight * self.scale, bias=self.bias * self.lr_mul
)
return out
def __repr__(self):
return (
f'{self.__class__.__name__}({self.weight.shape[1]}, {self.weight.shape[0]})'
)
class ScaledLeakyReLU(nn.Module):
def __init__(self, negative_slope=0.2):
super().__init__()
self.negative_slope = negative_slope
def forward(self, input):
out = F.leaky_relu(input, negative_slope=self.negative_slope)
return out * math.sqrt(2)
class ModulatedConv2d(nn.Module):
def __init__(
self,
in_channel,
out_channel,
kernel_size,
style_dim,
demodulate=True,
upsample=False,
downsample=False,
blur_kernel=[1, 3, 3, 1],
):
super().__init__()
self.eps = 1e-8
self.kernel_size = kernel_size
self.in_channel = in_channel
self.out_channel = out_channel
self.upsample = upsample
self.downsample = downsample
if upsample:
factor = 2
p = (len(blur_kernel) - factor) - (kernel_size - 1)
pad0 = (p + 1) // 2 + factor - 1
pad1 = p // 2 + 1
self.blur = Blur(blur_kernel, pad=(pad0, pad1), upsample_factor=factor)
if downsample:
factor = 2
p = (len(blur_kernel) - factor) + (kernel_size - 1)
pad0 = (p + 1) // 2
pad1 = p // 2
self.blur = Blur(blur_kernel, pad=(pad0, pad1))
fan_in = in_channel * kernel_size ** 2
self.scale = math.sqrt(1) / math.sqrt(fan_in)
self.padding = kernel_size // 2
self.weight = nn.Parameter(
torch.randn(1, out_channel, in_channel, kernel_size, kernel_size)
)
if style_dim is not None and style_dim > 0:
self.modulation = EqualLinear(style_dim, in_channel, bias_init=1)
self.demodulate = demodulate
def __repr__(self):
return (
f'{self.__class__.__name__}({self.in_channel}, {self.out_channel}, {self.kernel_size}, '
f'upsample={self.upsample}, downsample={self.downsample})'
)
def forward(self, input, style):
batch, in_channel, height, width = input.shape
if style is not None:
style = self.modulation(style).view(batch, 1, in_channel, 1, 1)
else:
style = torch.ones(batch, 1, in_channel, 1, 1).cuda()
weight = self.scale * self.weight * style
if self.demodulate:
demod = torch.rsqrt(weight.pow(2).sum([2, 3, 4]) + 1e-8)
weight = weight * demod.view(batch, self.out_channel, 1, 1, 1)
weight = weight.view(
batch * self.out_channel, in_channel, self.kernel_size, self.kernel_size
)
if self.upsample:
input = input.view(1, batch * in_channel, height, width)
weight = weight.view(
batch, self.out_channel, in_channel, self.kernel_size, self.kernel_size
)
weight = weight.transpose(1, 2).reshape(
batch * in_channel, self.out_channel, self.kernel_size, self.kernel_size
)
out = F.conv_transpose2d(input, weight, padding=0, stride=2, groups=batch)
_, _, height, width = out.shape
out = out.view(batch, self.out_channel, height, width)
out = self.blur(out)
elif self.downsample:
input = self.blur(input)
_, _, height, width = input.shape
input = input.view(1, batch * in_channel, height, width)
out = F.conv2d(input, weight, padding=0, stride=2, groups=batch)
_, _, height, width = out.shape
out = out.view(batch, self.out_channel, height, width)
else:
input = input.view(1, batch * in_channel, height, width)
out = F.conv2d(input, weight, padding=self.padding, groups=batch)
_, _, height, width = out.shape
out = out.view(batch, self.out_channel, height, width)
return out
class NoiseInjection(nn.Module):
def __init__(self):
super().__init__()
self.weight = nn.Parameter(torch.zeros(1))
def forward(self, image, noise=None):
if noise is None:
batch, _, height, width = image.shape
noise = image.new_empty(batch, 1, height, width).normal_()
return image + self.weight * noise
class ConstantInput(nn.Module):
def __init__(self, channel, size=4):
super().__init__()
self.input = nn.Parameter(torch.randn(1, channel, size, size))
def forward(self, input):
batch = input.shape[0]
out = self.input.repeat(batch, 1, 1, 1)
return out
class StyledConv(nn.Module):
def __init__(
self,
in_channel,
out_channel,
kernel_size,
style_dim=None,
upsample=False,
blur_kernel=[1, 3, 3, 1],
demodulate=True,
inject_noise=True,
):
super().__init__()
self.inject_noise = inject_noise
self.conv = ModulatedConv2d(
in_channel,
out_channel,
kernel_size,
style_dim,
upsample=upsample,
blur_kernel=blur_kernel,
demodulate=demodulate,
)
self.noise = NoiseInjection()
# self.bias = nn.Parameter(torch.zeros(1, out_channel, 1, 1))
# self.activate = ScaledLeakyReLU(0.2)
self.activate = FusedLeakyReLU(out_channel)
def forward(self, input, style=None, noise=None):
out = self.conv(input, style)
if self.inject_noise:
out = self.noise(out, noise=noise)
# out = out + self.bias
out = self.activate(out)
return out
class ToRGB(nn.Module):
def __init__(self, in_channel, style_dim, upsample=True, blur_kernel=[1, 3, 3, 1]):
super().__init__()
if upsample:
self.upsample = Upsample(blur_kernel)
self.conv = ModulatedConv2d(in_channel, 3, 1, style_dim, demodulate=False)
self.bias = nn.Parameter(torch.zeros(1, 3, 1, 1))
def forward(self, input, style, skip=None):
out = self.conv(input, style)
out = out + self.bias
if skip is not None:
skip = self.upsample(skip)
out = out + skip
return out
class Generator(nn.Module):
def __init__(
self,
size,
style_dim,
n_mlp,
channel_multiplier=2,
blur_kernel=[1, 3, 3, 1],
lr_mlp=0.01,
):
super().__init__()
self.size = size
self.style_dim = style_dim
layers = [PixelNorm()]
for i in range(n_mlp):
layers.append(
EqualLinear(
style_dim, style_dim, lr_mul=lr_mlp, activation='fused_lrelu'
)
)
self.style = nn.Sequential(*layers)
self.channels = {
4: 512,
8: 512,
16: 512,
32: 512,
64: 256 * channel_multiplier,
128: 128 * channel_multiplier,
256: 64 * channel_multiplier,
512: 32 * channel_multiplier,
1024: 16 * channel_multiplier,
}
self.input = ConstantInput(self.channels[4])
self.conv1 = StyledConv(
self.channels[4], self.channels[4], 3, style_dim, blur_kernel=blur_kernel
)
self.to_rgb1 = ToRGB(self.channels[4], style_dim, upsample=False)
self.log_size = int(math.log(size, 2))
self.num_layers = (self.log_size - 2) * 2 + 1
self.convs = nn.ModuleList()
self.upsamples = nn.ModuleList()
self.to_rgbs = nn.ModuleList()
self.noises = nn.Module()
in_channel = self.channels[4]
for layer_idx in range(self.num_layers):
res = (layer_idx + 5) // 2
shape = [1, 1, 2 ** res, 2 ** res]
self.noises.register_buffer(f'noise_{layer_idx}', torch.randn(*shape))
for i in range(3, self.log_size + 1):
out_channel = self.channels[2 ** i]
self.convs.append(
StyledConv(
in_channel,
out_channel,
3,
style_dim,
upsample=True,
blur_kernel=blur_kernel,
)
)
self.convs.append(
StyledConv(
out_channel, out_channel, 3, style_dim, blur_kernel=blur_kernel
)
)
self.to_rgbs.append(ToRGB(out_channel, style_dim))
in_channel = out_channel
self.n_latent = self.log_size * 2 - 2
def make_noise(self):
device = self.input.input.device
noises = [torch.randn(1, 1, 2 ** 2, 2 ** 2, device=device)]
for i in range(3, self.log_size + 1):
for _ in range(2):
noises.append(torch.randn(1, 1, 2 ** i, 2 ** i, device=device))
return noises
def mean_latent(self, n_latent):
latent_in = torch.randn(
n_latent, self.style_dim, device=self.input.input.device
)
latent = self.style(latent_in).mean(0, keepdim=True)
return latent
def get_latent(self, input):
return self.style(input)
def forward(
self,
styles,
return_latents=False,
inject_index=None,
truncation=1,
truncation_latent=None,
input_is_latent=False,
noise=None,
randomize_noise=True,
):
if not input_is_latent:
styles = [self.style(s) for s in styles]
if noise is None:
if randomize_noise:
noise = [None] * self.num_layers
else:
noise = [
getattr(self.noises, f'noise_{i}') for i in range(self.num_layers)
]
if truncation < 1:
style_t = []
for style in styles:
style_t.append(
truncation_latent + truncation * (style - truncation_latent)
)
styles = style_t
if len(styles) < 2:
inject_index = self.n_latent
if len(styles[0].shape) < 3:
latent = styles[0].unsqueeze(1).repeat(1, inject_index, 1)
else:
latent = styles[0]
else:
if inject_index is None:
inject_index = random.randint(1, self.n_latent - 1)
latent = styles[0].unsqueeze(1).repeat(1, inject_index, 1)
latent2 = styles[1].unsqueeze(1).repeat(1, self.n_latent - inject_index, 1)
latent = torch.cat([latent, latent2], 1)
out = self.input(latent)
out = self.conv1(out, latent[:, 0], noise=noise[0])
skip = self.to_rgb1(out, latent[:, 1])
i = 1
for conv1, conv2, noise1, noise2, to_rgb in zip(
self.convs[::2], self.convs[1::2], noise[1::2], noise[2::2], self.to_rgbs
):
out = conv1(out, latent[:, i], noise=noise1)
out = conv2(out, latent[:, i + 1], noise=noise2)
skip = to_rgb(out, latent[:, i + 2], skip)
i += 2
image = skip
if return_latents:
return image, latent
else:
return image, None
class ConvLayer(nn.Sequential):
def __init__(
self,
in_channel,
out_channel,
kernel_size,
downsample=False,
blur_kernel=[1, 3, 3, 1],
bias=True,
activate=True,
):
layers = []
if downsample:
factor = 2
p = (len(blur_kernel) - factor) + (kernel_size - 1)
pad0 = (p + 1) // 2
pad1 = p // 2
layers.append(Blur(blur_kernel, pad=(pad0, pad1)))
stride = 2
self.padding = 0
else:
stride = 1
self.padding = kernel_size // 2
layers.append(
EqualConv2d(
in_channel,
out_channel,
kernel_size,
padding=self.padding,
stride=stride,
bias=bias and not activate,
)
)
if activate:
if bias:
layers.append(FusedLeakyReLU(out_channel))
else:
layers.append(ScaledLeakyReLU(0.2))
super().__init__(*layers)
class ResBlock(nn.Module):
def __init__(self, in_channel, out_channel, blur_kernel=[1, 3, 3, 1], downsample=True, skip_gain=1.0):
super().__init__()
self.skip_gain = skip_gain
self.conv1 = ConvLayer(in_channel, in_channel, 3)
self.conv2 = ConvLayer(in_channel, out_channel, 3, downsample=downsample, blur_kernel=blur_kernel)
if in_channel != out_channel or downsample:
self.skip = ConvLayer(
in_channel, out_channel, 1, downsample=downsample, activate=False, bias=False
)
else:
self.skip = nn.Identity()
def forward(self, input):
out = self.conv1(input)
out = self.conv2(out)
skip = self.skip(input)
out = (out * self.skip_gain + skip) / math.sqrt(self.skip_gain ** 2 + 1.0)
return out
class StyleGAN2Discriminator(nn.Module):
def __init__(self, input_nc, ndf=64, n_layers=3, no_antialias=False, size=None, opt=None):
super().__init__()
self.opt = opt
self.stddev_group = 16
if size is None:
size = 2 ** int((np.rint(np.log2(min(opt.load_size, opt.crop_size)))))
if "patch" in self.opt.netD and self.opt.D_patch_size is not None:
size = 2 ** int(np.log2(self.opt.D_patch_size))
blur_kernel = [1, 3, 3, 1]
channel_multiplier = ndf / 64
channels = {
4: min(384, int(4096 * channel_multiplier)),
8: min(384, int(2048 * channel_multiplier)),
16: min(384, int(1024 * channel_multiplier)),
32: min(384, int(512 * channel_multiplier)),
64: int(256 * channel_multiplier),
128: int(128 * channel_multiplier),
256: int(64 * channel_multiplier),
512: int(32 * channel_multiplier),
1024: int(16 * channel_multiplier),
}
convs = [ConvLayer(3, channels[size], 1)]
log_size = int(math.log(size, 2))
in_channel = channels[size]
if "smallpatch" in self.opt.netD:
final_res_log2 = 4
elif "patch" in self.opt.netD:
final_res_log2 = 3
else:
final_res_log2 = 2
for i in range(log_size, final_res_log2, -1):
out_channel = channels[2 ** (i - 1)]
convs.append(ResBlock(in_channel, out_channel, blur_kernel))
in_channel = out_channel
self.convs = nn.Sequential(*convs)
if False and "tile" in self.opt.netD:
in_channel += 1
self.final_conv = ConvLayer(in_channel, channels[4], 3)
if "patch" in self.opt.netD:
self.final_linear = ConvLayer(channels[4], 1, 3, bias=False, activate=False)
else:
self.final_linear = nn.Sequential(
EqualLinear(channels[4] * 4 * 4, channels[4], activation='fused_lrelu'),
EqualLinear(channels[4], 1),
)
def forward(self, input, get_minibatch_features=False):
if "patch" in self.opt.netD and self.opt.D_patch_size is not None:
h, w = input.size(2), input.size(3)
y = torch.randint(h - self.opt.D_patch_size, ())
x = torch.randint(w - self.opt.D_patch_size, ())
input = input[:, :, y:y + self.opt.D_patch_size, x:x + self.opt.D_patch_size]
out = input
for i, conv in enumerate(self.convs):
out = conv(out)
# print(i, out.abs().mean())
# out = self.convs(input)
batch, channel, height, width = out.shape
if False and "tile" in self.opt.netD:
group = min(batch, self.stddev_group)
stddev = out.view(
group, -1, 1, channel // 1, height, width
)
stddev = torch.sqrt(stddev.var(0, unbiased=False) + 1e-8)
stddev = stddev.mean([2, 3, 4], keepdim=True).squeeze(2)
stddev = stddev.repeat(group, 1, height, width)
out = torch.cat([out, stddev], 1)
out = self.final_conv(out)
# print(out.abs().mean())
if "patch" not in self.opt.netD:
out = out.view(batch, -1)
out = self.final_linear(out)
return out
class TileStyleGAN2Discriminator(StyleGAN2Discriminator):
def forward(self, input):
B, C, H, W = input.size(0), input.size(1), input.size(2), input.size(3)
size = self.opt.D_patch_size
Y = H // size
X = W // size
input = input.view(B, C, Y, size, X, size)
input = input.permute(0, 2, 4, 1, 3, 5).contiguous().view(B * Y * X, C, size, size)
return super().forward(input)
class StyleGAN2Encoder(nn.Module):
def __init__(self, input_nc, output_nc, ngf=64, use_dropout=False, n_blocks=6, padding_type='reflect', no_antialias=False, opt=None):
super().__init__()
assert opt is not None
self.opt = opt
channel_multiplier = ngf / 32
channels = {
4: min(512, int(round(4096 * channel_multiplier))),
8: min(512, int(round(2048 * channel_multiplier))),
16: min(512, int(round(1024 * channel_multiplier))),
32: min(512, int(round(512 * channel_multiplier))),
64: int(round(256 * channel_multiplier)),
128: int(round(128 * channel_multiplier)),
256: int(round(64 * channel_multiplier)),
512: int(round(32 * channel_multiplier)),
1024: int(round(16 * channel_multiplier)),
}
blur_kernel = [1, 3, 3, 1]
cur_res = 2 ** int((np.rint(np.log2(min(opt.load_size, opt.crop_size)))))
convs = [nn.Identity(),
ConvLayer(3, channels[cur_res], 1)]
num_downsampling = self.opt.stylegan2_G_num_downsampling
for i in range(num_downsampling):
in_channel = channels[cur_res]
out_channel = channels[cur_res // 2]
convs.append(ResBlock(in_channel, out_channel, blur_kernel, downsample=True))
cur_res = cur_res // 2
for i in range(n_blocks // 2):
n_channel = channels[cur_res]
convs.append(ResBlock(n_channel, n_channel, downsample=False))
self.convs = nn.Sequential(*convs)
def forward(self, input, layers=[], get_features=False):
feat = input
feats = []
if -1 in layers:
layers.append(len(self.convs) - 1)
for layer_id, layer in enumerate(self.convs):
feat = layer(feat)
# print(layer_id, " features ", feat.abs().mean())
if layer_id in layers:
feats.append(feat)
if get_features:
return feat, feats
else:
return feat
class StyleGAN2Decoder(nn.Module):
def __init__(self, input_nc, output_nc, ngf=64, use_dropout=False, n_blocks=6, padding_type='reflect', no_antialias=False, opt=None):
super().__init__()
assert opt is not None
self.opt = opt
blur_kernel = [1, 3, 3, 1]
channel_multiplier = ngf / 32
channels = {
4: min(512, int(round(4096 * channel_multiplier))),
8: min(512, int(round(2048 * channel_multiplier))),
16: min(512, int(round(1024 * channel_multiplier))),
32: min(512, int(round(512 * channel_multiplier))),
64: int(round(256 * channel_multiplier)),
128: int(round(128 * channel_multiplier)),
256: int(round(64 * channel_multiplier)),
512: int(round(32 * channel_multiplier)),
1024: int(round(16 * channel_multiplier)),
}
num_downsampling = self.opt.stylegan2_G_num_downsampling
cur_res = 2 ** int((np.rint(np.log2(min(opt.load_size, opt.crop_size))))) // (2 ** num_downsampling)
convs = []
for i in range(n_blocks // 2):
n_channel = channels[cur_res]
convs.append(ResBlock(n_channel, n_channel, downsample=False))
for i in range(num_downsampling):
in_channel = channels[cur_res]
out_channel = channels[cur_res * 2]
inject_noise = "small" not in self.opt.netG
convs.append(
StyledConv(in_channel, out_channel, 3, upsample=True, blur_kernel=blur_kernel, inject_noise=inject_noise)
)
cur_res = cur_res * 2
convs.append(ConvLayer(channels[cur_res], 3, 1))
self.convs = nn.Sequential(*convs)
def forward(self, input):
return self.convs(input)
class StyleGAN2Generator(nn.Module):
def __init__(self, input_nc, output_nc, ngf=64, use_dropout=False, n_blocks=6, padding_type='reflect', no_antialias=False, opt=None):
super().__init__()
self.opt = opt
self.encoder = StyleGAN2Encoder(input_nc, output_nc, ngf, use_dropout, n_blocks, padding_type, no_antialias, opt)
self.decoder = StyleGAN2Decoder(input_nc, output_nc, ngf, use_dropout, n_blocks, padding_type, no_antialias, opt)
def forward(self, input, layers=[], encode_only=False):
feat, feats = self.encoder(input, layers, True)
if encode_only:
return feats
else:
fake = self.decoder(feat)
if len(layers) > 0:
return fake, feats
else:
return fake
| 27,899 | 29.491803 | 137 | py |
contrastive-unpaired-translation | contrastive-unpaired-translation-master/models/patchnce.py | from packaging import version
import torch
from torch import nn
class PatchNCELoss(nn.Module):
def __init__(self, opt):
super().__init__()
self.opt = opt
self.cross_entropy_loss = torch.nn.CrossEntropyLoss(reduction='none')
self.mask_dtype = torch.uint8 if version.parse(torch.__version__) < version.parse('1.2.0') else torch.bool
def forward(self, feat_q, feat_k):
num_patches = feat_q.shape[0]
dim = feat_q.shape[1]
feat_k = feat_k.detach()
# pos logit
l_pos = torch.bmm(
feat_q.view(num_patches, 1, -1), feat_k.view(num_patches, -1, 1))
l_pos = l_pos.view(num_patches, 1)
# neg logit
# Should the negatives from the other samples of a minibatch be utilized?
# In CUT and FastCUT, we found that it's best to only include negatives
# from the same image. Therefore, we set
# --nce_includes_all_negatives_from_minibatch as False
# However, for single-image translation, the minibatch consists of
# crops from the "same" high-resolution image.
# Therefore, we will include the negatives from the entire minibatch.
if self.opt.nce_includes_all_negatives_from_minibatch:
# reshape features as if they are all negatives of minibatch of size 1.
batch_dim_for_bmm = 1
else:
batch_dim_for_bmm = self.opt.batch_size
# reshape features to batch size
feat_q = feat_q.view(batch_dim_for_bmm, -1, dim)
feat_k = feat_k.view(batch_dim_for_bmm, -1, dim)
npatches = feat_q.size(1)
l_neg_curbatch = torch.bmm(feat_q, feat_k.transpose(2, 1))
# diagonal entries are similarity between same features, and hence meaningless.
# just fill the diagonal with very small number, which is exp(-10) and almost zero
diagonal = torch.eye(npatches, device=feat_q.device, dtype=self.mask_dtype)[None, :, :]
l_neg_curbatch.masked_fill_(diagonal, -10.0)
l_neg = l_neg_curbatch.view(-1, npatches)
out = torch.cat((l_pos, l_neg), dim=1) / self.opt.nce_T
loss = self.cross_entropy_loss(out, torch.zeros(out.size(0), dtype=torch.long,
device=feat_q.device))
return loss
| 2,319 | 40.428571 | 114 | py |
contrastive-unpaired-translation | contrastive-unpaired-translation-master/models/cut_model.py | import numpy as np
import torch
from .base_model import BaseModel
from . import networks
from .patchnce import PatchNCELoss
import util.util as util
class CUTModel(BaseModel):
""" This class implements CUT and FastCUT model, described in the paper
Contrastive Learning for Unpaired Image-to-Image Translation
Taesung Park, Alexei A. Efros, Richard Zhang, Jun-Yan Zhu
ECCV, 2020
The code borrows heavily from the PyTorch implementation of CycleGAN
https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix
"""
@staticmethod
def modify_commandline_options(parser, is_train=True):
""" Configures options specific for CUT model
"""
parser.add_argument('--CUT_mode', type=str, default="CUT", choices='(CUT, cut, FastCUT, fastcut)')
parser.add_argument('--lambda_GAN', type=float, default=1.0, help='weight for GAN loss：GAN(G(X))')
parser.add_argument('--lambda_NCE', type=float, default=1.0, help='weight for NCE loss: NCE(G(X), X)')
parser.add_argument('--nce_idt', type=util.str2bool, nargs='?', const=True, default=False, help='use NCE loss for identity mapping: NCE(G(Y), Y))')
parser.add_argument('--nce_layers', type=str, default='0,4,8,12,16', help='compute NCE loss on which layers')
parser.add_argument('--nce_includes_all_negatives_from_minibatch',
type=util.str2bool, nargs='?', const=True, default=False,
help='(used for single image translation) If True, include the negatives from the other samples of the minibatch when computing the contrastive loss. Please see models/patchnce.py for more details.')
parser.add_argument('--netF', type=str, default='mlp_sample', choices=['sample', 'reshape', 'mlp_sample'], help='how to downsample the feature map')
parser.add_argument('--netF_nc', type=int, default=256)
parser.add_argument('--nce_T', type=float, default=0.07, help='temperature for NCE loss')
parser.add_argument('--num_patches', type=int, default=256, help='number of patches per layer')
parser.add_argument('--flip_equivariance',
type=util.str2bool, nargs='?', const=True, default=False,
help="Enforce flip-equivariance as additional regularization. It's used by FastCUT, but not CUT")
parser.set_defaults(pool_size=0) # no image pooling
opt, _ = parser.parse_known_args()
# Set default parameters for CUT and FastCUT
if opt.CUT_mode.lower() == "cut":
parser.set_defaults(nce_idt=True, lambda_NCE=1.0)
elif opt.CUT_mode.lower() == "fastcut":
parser.set_defaults(
nce_idt=False, lambda_NCE=10.0, flip_equivariance=True,
n_epochs=150, n_epochs_decay=50
)
else:
raise ValueError(opt.CUT_mode)
return parser
def __init__(self, opt):
BaseModel.__init__(self, opt)
# specify the training losses you want to print out.
# The training/test scripts will call <BaseModel.get_current_losses>
self.loss_names = ['G_GAN', 'D_real', 'D_fake', 'G', 'NCE']
self.visual_names = ['real_A', 'fake_B', 'real_B']
self.nce_layers = [int(i) for i in self.opt.nce_layers.split(',')]
if opt.nce_idt and self.isTrain:
self.loss_names += ['NCE_Y']
self.visual_names += ['idt_B']
if self.isTrain:
self.model_names = ['G', 'F', 'D']
else: # during test time, only load G
self.model_names = ['G']
# define networks (both generator and discriminator)
self.netG = networks.define_G(opt.input_nc, opt.output_nc, opt.ngf, opt.netG, opt.normG, not opt.no_dropout, opt.init_type, opt.init_gain, opt.no_antialias, opt.no_antialias_up, self.gpu_ids, opt)
self.netF = networks.define_F(opt.input_nc, opt.netF, opt.normG, not opt.no_dropout, opt.init_type, opt.init_gain, opt.no_antialias, self.gpu_ids, opt)
if self.isTrain:
self.netD = networks.define_D(opt.output_nc, opt.ndf, opt.netD, opt.n_layers_D, opt.normD, opt.init_type, opt.init_gain, opt.no_antialias, self.gpu_ids, opt)
# define loss functions
self.criterionGAN = networks.GANLoss(opt.gan_mode).to(self.device)
self.criterionNCE = []
for nce_layer in self.nce_layers:
self.criterionNCE.append(PatchNCELoss(opt).to(self.device))
self.criterionIdt = torch.nn.L1Loss().to(self.device)
self.optimizer_G = torch.optim.Adam(self.netG.parameters(), lr=opt.lr, betas=(opt.beta1, opt.beta2))
self.optimizer_D = torch.optim.Adam(self.netD.parameters(), lr=opt.lr, betas=(opt.beta1, opt.beta2))
self.optimizers.append(self.optimizer_G)
self.optimizers.append(self.optimizer_D)
def data_dependent_initialize(self, data):
"""
The feature network netF is defined in terms of the shape of the intermediate, extracted
features of the encoder portion of netG. Because of this, the weights of netF are
initialized at the first feedforward pass with some input images.
Please also see PatchSampleF.create_mlp(), which is called at the first forward() call.
"""
bs_per_gpu = data["A"].size(0) // max(len(self.opt.gpu_ids), 1)
self.set_input(data)
self.real_A = self.real_A[:bs_per_gpu]
self.real_B = self.real_B[:bs_per_gpu]
self.forward() # compute fake images: G(A)
if self.opt.isTrain:
self.compute_D_loss().backward() # calculate gradients for D
self.compute_G_loss().backward() # calculate graidents for G
if self.opt.lambda_NCE > 0.0:
self.optimizer_F = torch.optim.Adam(self.netF.parameters(), lr=self.opt.lr, betas=(self.opt.beta1, self.opt.beta2))
self.optimizers.append(self.optimizer_F)
def optimize_parameters(self):
# forward
self.forward()
# update D
self.set_requires_grad(self.netD, True)
self.optimizer_D.zero_grad()
self.loss_D = self.compute_D_loss()
self.loss_D.backward()
self.optimizer_D.step()
# update G
self.set_requires_grad(self.netD, False)
self.optimizer_G.zero_grad()
if self.opt.netF == 'mlp_sample':
self.optimizer_F.zero_grad()
self.loss_G = self.compute_G_loss()
self.loss_G.backward()
self.optimizer_G.step()
if self.opt.netF == 'mlp_sample':
self.optimizer_F.step()
def set_input(self, input):
"""Unpack input data from the dataloader and perform necessary pre-processing steps.
Parameters:
input (dict): include the data itself and its metadata information.
The option 'direction' can be used to swap domain A and domain B.
"""
AtoB = self.opt.direction == 'AtoB'
self.real_A = input['A' if AtoB else 'B'].to(self.device)
self.real_B = input['B' if AtoB else 'A'].to(self.device)
self.image_paths = input['A_paths' if AtoB else 'B_paths']
def forward(self):
"""Run forward pass; called by both functions <optimize_parameters> and <test>."""
self.real = torch.cat((self.real_A, self.real_B), dim=0) if self.opt.nce_idt and self.opt.isTrain else self.real_A
if self.opt.flip_equivariance:
self.flipped_for_equivariance = self.opt.isTrain and (np.random.random() < 0.5)
if self.flipped_for_equivariance:
self.real = torch.flip(self.real, [3])
self.fake = self.netG(self.real)
self.fake_B = self.fake[:self.real_A.size(0)]
if self.opt.nce_idt:
self.idt_B = self.fake[self.real_A.size(0):]
def compute_D_loss(self):
"""Calculate GAN loss for the discriminator"""
fake = self.fake_B.detach()
# Fake; stop backprop to the generator by detaching fake_B
pred_fake = self.netD(fake)
self.loss_D_fake = self.criterionGAN(pred_fake, False).mean()
# Real
self.pred_real = self.netD(self.real_B)
loss_D_real = self.criterionGAN(self.pred_real, True)
self.loss_D_real = loss_D_real.mean()
# combine loss and calculate gradients
self.loss_D = (self.loss_D_fake + self.loss_D_real) * 0.5
return self.loss_D
def compute_G_loss(self):
"""Calculate GAN and NCE loss for the generator"""
fake = self.fake_B
# First, G(A) should fake the discriminator
if self.opt.lambda_GAN > 0.0:
pred_fake = self.netD(fake)
self.loss_G_GAN = self.criterionGAN(pred_fake, True).mean() * self.opt.lambda_GAN
else:
self.loss_G_GAN = 0.0
if self.opt.lambda_NCE > 0.0:
self.loss_NCE = self.calculate_NCE_loss(self.real_A, self.fake_B)
else:
self.loss_NCE, self.loss_NCE_bd = 0.0, 0.0
if self.opt.nce_idt and self.opt.lambda_NCE > 0.0:
self.loss_NCE_Y = self.calculate_NCE_loss(self.real_B, self.idt_B)
loss_NCE_both = (self.loss_NCE + self.loss_NCE_Y) * 0.5
else:
loss_NCE_both = self.loss_NCE
self.loss_G = self.loss_G_GAN + loss_NCE_both
return self.loss_G
def calculate_NCE_loss(self, src, tgt):
n_layers = len(self.nce_layers)
feat_q = self.netG(tgt, self.nce_layers, encode_only=True)
if self.opt.flip_equivariance and self.flipped_for_equivariance:
feat_q = [torch.flip(fq, [3]) for fq in feat_q]
feat_k = self.netG(src, self.nce_layers, encode_only=True)
feat_k_pool, sample_ids = self.netF(feat_k, self.opt.num_patches, None)
feat_q_pool, _ = self.netF(feat_q, self.opt.num_patches, sample_ids)
total_nce_loss = 0.0
for f_q, f_k, crit, nce_layer in zip(feat_q_pool, feat_k_pool, self.criterionNCE, self.nce_layers):
loss = crit(f_q, f_k) * self.opt.lambda_NCE
total_nce_loss += loss.mean()
return total_nce_loss / n_layers
| 10,226 | 46.567442 | 227 | py |
contrastive-unpaired-translation | contrastive-unpaired-translation-master/models/sincut_model.py | import torch
from .cut_model import CUTModel
class SinCUTModel(CUTModel):
""" This class implements the single image translation model (Fig 9) of
Contrastive Learning for Unpaired Image-to-Image Translation
Taesung Park, Alexei A. Efros, Richard Zhang, Jun-Yan Zhu
ECCV, 2020
"""
@staticmethod
def modify_commandline_options(parser, is_train=True):
parser = CUTModel.modify_commandline_options(parser, is_train)
parser.add_argument('--lambda_R1', type=float, default=1.0,
help='weight for the R1 gradient penalty')
parser.add_argument('--lambda_identity', type=float, default=1.0,
help='the "identity preservation loss"')
parser.set_defaults(nce_includes_all_negatives_from_minibatch=True,
dataset_mode="singleimage",
netG="stylegan2",
stylegan2_G_num_downsampling=1,
netD="stylegan2",
gan_mode="nonsaturating",
num_patches=1,
nce_layers="0,2,4",
lambda_NCE=4.0,
ngf=10,
ndf=8,
lr=0.002,
beta1=0.0,
beta2=0.99,
load_size=1024,
crop_size=64,
preprocess="zoom_and_patch",
)
if is_train:
parser.set_defaults(preprocess="zoom_and_patch",
batch_size=16,
save_epoch_freq=1,
save_latest_freq=20000,
n_epochs=8,
n_epochs_decay=8,
)
else:
parser.set_defaults(preprocess="none", # load the whole image as it is
batch_size=1,
num_test=1,
)
return parser
def __init__(self, opt):
super().__init__(opt)
if self.isTrain:
if opt.lambda_R1 > 0.0:
self.loss_names += ['D_R1']
if opt.lambda_identity > 0.0:
self.loss_names += ['idt']
def compute_D_loss(self):
self.real_B.requires_grad_()
GAN_loss_D = super().compute_D_loss()
self.loss_D_R1 = self.R1_loss(self.pred_real, self.real_B)
self.loss_D = GAN_loss_D + self.loss_D_R1
return self.loss_D
def compute_G_loss(self):
CUT_loss_G = super().compute_G_loss()
self.loss_idt = torch.nn.functional.l1_loss(self.idt_B, self.real_B) * self.opt.lambda_identity
return CUT_loss_G + self.loss_idt
def R1_loss(self, real_pred, real_img):
grad_real, = torch.autograd.grad(outputs=real_pred.sum(), inputs=real_img, create_graph=True, retain_graph=True)
grad_penalty = grad_real.pow(2).view(grad_real.shape[0], -1).sum(1).mean()
return grad_penalty * (self.opt.lambda_R1 * 0.5)
| 3,168 | 38.6125 | 120 | py |
contrastive-unpaired-translation | contrastive-unpaired-translation-master/models/networks.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import init
import functools
from torch.optim import lr_scheduler
import numpy as np
from .stylegan_networks import StyleGAN2Discriminator, StyleGAN2Generator, TileStyleGAN2Discriminator
###############################################################################
# Helper Functions
###############################################################################
def get_filter(filt_size=3):
if(filt_size == 1):
a = np.array([1., ])
elif(filt_size == 2):
a = np.array([1., 1.])
elif(filt_size == 3):
a = np.array([1., 2., 1.])
elif(filt_size == 4):
a = np.array([1., 3., 3., 1.])
elif(filt_size == 5):
a = np.array([1., 4., 6., 4., 1.])
elif(filt_size == 6):
a = np.array([1., 5., 10., 10., 5., 1.])
elif(filt_size == 7):
a = np.array([1., 6., 15., 20., 15., 6., 1.])
filt = torch.Tensor(a[:, None] * a[None, :])
filt = filt / torch.sum(filt)
return filt
class Downsample(nn.Module):
def __init__(self, channels, pad_type='reflect', filt_size=3, stride=2, pad_off=0):
super(Downsample, self).__init__()
self.filt_size = filt_size
self.pad_off = pad_off
self.pad_sizes = [int(1. * (filt_size - 1) / 2), int(np.ceil(1. * (filt_size - 1) / 2)), int(1. * (filt_size - 1) / 2), int(np.ceil(1. * (filt_size - 1) / 2))]
self.pad_sizes = [pad_size + pad_off for pad_size in self.pad_sizes]
self.stride = stride
self.off = int((self.stride - 1) / 2.)
self.channels = channels
filt = get_filter(filt_size=self.filt_size)
self.register_buffer('filt', filt[None, None, :, :].repeat((self.channels, 1, 1, 1)))
self.pad = get_pad_layer(pad_type)(self.pad_sizes)
def forward(self, inp):
if(self.filt_size == 1):
if(self.pad_off == 0):
return inp[:, :, ::self.stride, ::self.stride]
else:
return self.pad(inp)[:, :, ::self.stride, ::self.stride]
else:
return F.conv2d(self.pad(inp), self.filt, stride=self.stride, groups=inp.shape[1])
class Upsample2(nn.Module):
def __init__(self, scale_factor, mode='nearest'):
super().__init__()
self.factor = scale_factor
self.mode = mode
def forward(self, x):
return torch.nn.functional.interpolate(x, scale_factor=self.factor, mode=self.mode)
class Upsample(nn.Module):
def __init__(self, channels, pad_type='repl', filt_size=4, stride=2):
super(Upsample, self).__init__()
self.filt_size = filt_size
self.filt_odd = np.mod(filt_size, 2) == 1
self.pad_size = int((filt_size - 1) / 2)
self.stride = stride
self.off = int((self.stride - 1) / 2.)
self.channels = channels
filt = get_filter(filt_size=self.filt_size) * (stride**2)
self.register_buffer('filt', filt[None, None, :, :].repeat((self.channels, 1, 1, 1)))
self.pad = get_pad_layer(pad_type)([1, 1, 1, 1])
def forward(self, inp):
ret_val = F.conv_transpose2d(self.pad(inp), self.filt, stride=self.stride, padding=1 + self.pad_size, groups=inp.shape[1])[:, :, 1:, 1:]
if(self.filt_odd):
return ret_val
else:
return ret_val[:, :, :-1, :-1]
def get_pad_layer(pad_type):
if(pad_type in ['refl', 'reflect']):
PadLayer = nn.ReflectionPad2d
elif(pad_type in ['repl', 'replicate']):
PadLayer = nn.ReplicationPad2d
elif(pad_type == 'zero'):
PadLayer = nn.ZeroPad2d
else:
print('Pad type [%s] not recognized' % pad_type)
return PadLayer
class Identity(nn.Module):
def forward(self, x):
return x
def get_norm_layer(norm_type='instance'):
"""Return a normalization layer
Parameters:
norm_type (str) -- the name of the normalization layer: batch | instance | none
For BatchNorm, we use learnable affine parameters and track running statistics (mean/stddev).
For InstanceNorm, we do not use learnable affine parameters. We do not track running statistics.
"""
if norm_type == 'batch':
norm_layer = functools.partial(nn.BatchNorm2d, affine=True, track_running_stats=True)
elif norm_type == 'instance':
norm_layer = functools.partial(nn.InstanceNorm2d, affine=False, track_running_stats=False)
elif norm_type == 'none':
def norm_layer(x):
return Identity()
else:
raise NotImplementedError('normalization layer [%s] is not found' % norm_type)
return norm_layer
def get_scheduler(optimizer, opt):
"""Return a learning rate scheduler
Parameters:
optimizer -- the optimizer of the network
opt (option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions．
opt.lr_policy is the name of learning rate policy: linear | step | plateau | cosine
For 'linear', we keep the same learning rate for the first <opt.n_epochs> epochs
and linearly decay the rate to zero over the next <opt.n_epochs_decay> epochs.
For other schedulers (step, plateau, and cosine), we use the default PyTorch schedulers.
See https://pytorch.org/docs/stable/optim.html for more details.
"""
if opt.lr_policy == 'linear':
def lambda_rule(epoch):
lr_l = 1.0 - max(0, epoch + opt.epoch_count - opt.n_epochs) / float(opt.n_epochs_decay + 1)
return lr_l
scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda_rule)
elif opt.lr_policy == 'step':
scheduler = lr_scheduler.StepLR(optimizer, step_size=opt.lr_decay_iters, gamma=0.1)
elif opt.lr_policy == 'plateau':
scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.2, threshold=0.01, patience=5)
elif opt.lr_policy == 'cosine':
scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max=opt.n_epochs, eta_min=0)
else:
return NotImplementedError('learning rate policy [%s] is not implemented', opt.lr_policy)
return scheduler
def init_weights(net, init_type='normal', init_gain=0.02, debug=False):
"""Initialize network weights.
Parameters:
net (network) -- network to be initialized
init_type (str) -- the name of an initialization method: normal | xavier | kaiming | orthogonal
init_gain (float) -- scaling factor for normal, xavier and orthogonal.
We use 'normal' in the original pix2pix and CycleGAN paper. But xavier and kaiming might
work better for some applications. Feel free to try yourself.
"""
def init_func(m): # define the initialization function
classname = m.__class__.__name__
if hasattr(m, 'weight') and (classname.find('Conv') != -1 or classname.find('Linear') != -1):
if debug:
print(classname)
if init_type == 'normal':
init.normal_(m.weight.data, 0.0, init_gain)
elif init_type == 'xavier':
init.xavier_normal_(m.weight.data, gain=init_gain)
elif init_type == 'kaiming':
init.kaiming_normal_(m.weight.data, a=0, mode='fan_in')
elif init_type == 'orthogonal':
init.orthogonal_(m.weight.data, gain=init_gain)
else:
raise NotImplementedError('initialization method [%s] is not implemented' % init_type)
if hasattr(m, 'bias') and m.bias is not None:
init.constant_(m.bias.data, 0.0)
elif classname.find('BatchNorm2d') != -1: # BatchNorm Layer's weight is not a matrix; only normal distribution applies.
init.normal_(m.weight.data, 1.0, init_gain)
init.constant_(m.bias.data, 0.0)
net.apply(init_func) # apply the initialization function <init_func>
def init_net(net, init_type='normal', init_gain=0.02, gpu_ids=[], debug=False, initialize_weights=True):
"""Initialize a network: 1. register CPU/GPU device (with multi-GPU support); 2. initialize the network weights
Parameters:
net (network) -- the network to be initialized
init_type (str) -- the name of an initialization method: normal | xavier | kaiming | orthogonal
gain (float) -- scaling factor for normal, xavier and orthogonal.
gpu_ids (int list) -- which GPUs the network runs on: e.g., 0,1,2
Return an initialized network.
"""
if len(gpu_ids) > 0:
assert(torch.cuda.is_available())
net.to(gpu_ids[0])
# if not amp:
# net = torch.nn.DataParallel(net, gpu_ids) # multi-GPUs for non-AMP training
if initialize_weights:
init_weights(net, init_type, init_gain=init_gain, debug=debug)
return net
def define_G(input_nc, output_nc, ngf, netG, norm='batch', use_dropout=False, init_type='normal',
init_gain=0.02, no_antialias=False, no_antialias_up=False, gpu_ids=[], opt=None):
"""Create a generator
Parameters:
input_nc (int) -- the number of channels in input images
output_nc (int) -- the number of channels in output images
ngf (int) -- the number of filters in the last conv layer
netG (str) -- the architecture's name: resnet_9blocks | resnet_6blocks | unet_256 | unet_128
norm (str) -- the name of normalization layers used in the network: batch | instance | none
use_dropout (bool) -- if use dropout layers.
init_type (str) -- the name of our initialization method.
init_gain (float) -- scaling factor for normal, xavier and orthogonal.
gpu_ids (int list) -- which GPUs the network runs on: e.g., 0,1,2
Returns a generator
Our current implementation provides two types of generators:
U-Net: [unet_128] (for 128x128 input images) and [unet_256] (for 256x256 input images)
The original U-Net paper: https://arxiv.org/abs/1505.04597
Resnet-based generator: [resnet_6blocks] (with 6 Resnet blocks) and [resnet_9blocks] (with 9 Resnet blocks)
Resnet-based generator consists of several Resnet blocks between a few downsampling/upsampling operations.
We adapt Torch code from Justin Johnson's neural style transfer project (https://github.com/jcjohnson/fast-neural-style).
The generator has been initialized by <init_net>. It uses RELU for non-linearity.
"""
net = None
norm_layer = get_norm_layer(norm_type=norm)
if netG == 'resnet_9blocks':
net = ResnetGenerator(input_nc, output_nc, ngf, norm_layer=norm_layer, use_dropout=use_dropout, no_antialias=no_antialias, no_antialias_up=no_antialias_up, n_blocks=9, opt=opt)
elif netG == 'resnet_6blocks':
net = ResnetGenerator(input_nc, output_nc, ngf, norm_layer=norm_layer, use_dropout=use_dropout, no_antialias=no_antialias, no_antialias_up=no_antialias_up, n_blocks=6, opt=opt)
elif netG == 'resnet_4blocks':
net = ResnetGenerator(input_nc, output_nc, ngf, norm_layer=norm_layer, use_dropout=use_dropout, no_antialias=no_antialias, no_antialias_up=no_antialias_up, n_blocks=4, opt=opt)
elif netG == 'unet_128':
net = UnetGenerator(input_nc, output_nc, 7, ngf, norm_layer=norm_layer, use_dropout=use_dropout)
elif netG == 'unet_256':
net = UnetGenerator(input_nc, output_nc, 8, ngf, norm_layer=norm_layer, use_dropout=use_dropout)
elif netG == 'stylegan2':
net = StyleGAN2Generator(input_nc, output_nc, ngf, use_dropout=use_dropout, opt=opt)
elif netG == 'smallstylegan2':
net = StyleGAN2Generator(input_nc, output_nc, ngf, use_dropout=use_dropout, n_blocks=2, opt=opt)
elif netG == 'resnet_cat':
n_blocks = 8
net = G_Resnet(input_nc, output_nc, opt.nz, num_downs=2, n_res=n_blocks - 4, ngf=ngf, norm='inst', nl_layer='relu')
else:
raise NotImplementedError('Generator model name [%s] is not recognized' % netG)
return init_net(net, init_type, init_gain, gpu_ids, initialize_weights=('stylegan2' not in netG))
def define_F(input_nc, netF, norm='batch', use_dropout=False, init_type='normal', init_gain=0.02, no_antialias=False, gpu_ids=[], opt=None):
if netF == 'global_pool':
net = PoolingF()
elif netF == 'reshape':
net = ReshapeF()
elif netF == 'sample':
net = PatchSampleF(use_mlp=False, init_type=init_type, init_gain=init_gain, gpu_ids=gpu_ids, nc=opt.netF_nc)
elif netF == 'mlp_sample':
net = PatchSampleF(use_mlp=True, init_type=init_type, init_gain=init_gain, gpu_ids=gpu_ids, nc=opt.netF_nc)
elif netF == 'strided_conv':
net = StridedConvF(init_type=init_type, init_gain=init_gain, gpu_ids=gpu_ids)
else:
raise NotImplementedError('projection model name [%s] is not recognized' % netF)
return init_net(net, init_type, init_gain, gpu_ids)
def define_D(input_nc, ndf, netD, n_layers_D=3, norm='batch', init_type='normal', init_gain=0.02, no_antialias=False, gpu_ids=[], opt=None):
"""Create a discriminator
Parameters:
input_nc (int) -- the number of channels in input images
ndf (int) -- the number of filters in the first conv layer
netD (str) -- the architecture's name: basic | n_layers | pixel
n_layers_D (int) -- the number of conv layers in the discriminator; effective when netD=='n_layers'
norm (str) -- the type of normalization layers used in the network.
init_type (str) -- the name of the initialization method.
init_gain (float) -- scaling factor for normal, xavier and orthogonal.
gpu_ids (int list) -- which GPUs the network runs on: e.g., 0,1,2
Returns a discriminator
Our current implementation provides three types of discriminators:
[basic]: 'PatchGAN' classifier described in the original pix2pix paper.
It can classify whether 70×70 overlapping patches are real or fake.
Such a patch-level discriminator architecture has fewer parameters
than a full-image discriminator and can work on arbitrarily-sized images
in a fully convolutional fashion.
[n_layers]: With this mode, you cna specify the number of conv layers in the discriminator
with the parameter <n_layers_D> (default=3 as used in [basic] (PatchGAN).)
[pixel]: 1x1 PixelGAN discriminator can classify whether a pixel is real or not.
It encourages greater color diversity but has no effect on spatial statistics.
The discriminator has been initialized by <init_net>. It uses Leaky RELU for non-linearity.
"""
net = None
norm_layer = get_norm_layer(norm_type=norm)
if netD == 'basic': # default PatchGAN classifier
net = NLayerDiscriminator(input_nc, ndf, n_layers=3, norm_layer=norm_layer, no_antialias=no_antialias,)
elif netD == 'n_layers': # more options
net = NLayerDiscriminator(input_nc, ndf, n_layers_D, norm_layer=norm_layer, no_antialias=no_antialias,)
elif netD == 'pixel': # classify if each pixel is real or fake
net = PixelDiscriminator(input_nc, ndf, norm_layer=norm_layer)
elif 'stylegan2' in netD:
net = StyleGAN2Discriminator(input_nc, ndf, n_layers_D, no_antialias=no_antialias, opt=opt)
else:
raise NotImplementedError('Discriminator model name [%s] is not recognized' % netD)
return init_net(net, init_type, init_gain, gpu_ids,
initialize_weights=('stylegan2' not in netD))
##############################################################################
# Classes
##############################################################################
class GANLoss(nn.Module):
"""Define different GAN objectives.
The GANLoss class abstracts away the need to create the target label tensor
that has the same size as the input.
"""
def __init__(self, gan_mode, target_real_label=1.0, target_fake_label=0.0):
""" Initialize the GANLoss class.
Parameters:
gan_mode (str) - - the type of GAN objective. It currently supports vanilla, lsgan, and wgangp.
target_real_label (bool) - - label for a real image
target_fake_label (bool) - - label of a fake image
Note: Do not use sigmoid as the last layer of Discriminator.
LSGAN needs no sigmoid. vanilla GANs will handle it with BCEWithLogitsLoss.
"""
super(GANLoss, self).__init__()
self.register_buffer('real_label', torch.tensor(target_real_label))
self.register_buffer('fake_label', torch.tensor(target_fake_label))
self.gan_mode = gan_mode
if gan_mode == 'lsgan':
self.loss = nn.MSELoss()
elif gan_mode == 'vanilla':
self.loss = nn.BCEWithLogitsLoss()
elif gan_mode in ['wgangp', 'nonsaturating']:
self.loss = None
else:
raise NotImplementedError('gan mode %s not implemented' % gan_mode)
def get_target_tensor(self, prediction, target_is_real):
"""Create label tensors with the same size as the input.
Parameters:
prediction (tensor) - - tpyically the prediction from a discriminator
target_is_real (bool) - - if the ground truth label is for real images or fake images
Returns:
A label tensor filled with ground truth label, and with the size of the input
"""
if target_is_real:
target_tensor = self.real_label
else:
target_tensor = self.fake_label
return target_tensor.expand_as(prediction)
def __call__(self, prediction, target_is_real):
"""Calculate loss given Discriminator's output and grount truth labels.
Parameters:
prediction (tensor) - - tpyically the prediction output from a discriminator
target_is_real (bool) - - if the ground truth label is for real images or fake images
Returns:
the calculated loss.
"""
bs = prediction.size(0)
if self.gan_mode in ['lsgan', 'vanilla']:
target_tensor = self.get_target_tensor(prediction, target_is_real)
loss = self.loss(prediction, target_tensor)
elif self.gan_mode == 'wgangp':
if target_is_real:
loss = -prediction.mean()
else:
loss = prediction.mean()
elif self.gan_mode == 'nonsaturating':
if target_is_real:
loss = F.softplus(-prediction).view(bs, -1).mean(dim=1)
else:
loss = F.softplus(prediction).view(bs, -1).mean(dim=1)
return loss
def cal_gradient_penalty(netD, real_data, fake_data, device, type='mixed', constant=1.0, lambda_gp=10.0):
"""Calculate the gradient penalty loss, used in WGAN-GP paper https://arxiv.org/abs/1704.00028
Arguments:
netD (network) -- discriminator network
real_data (tensor array) -- real images
fake_data (tensor array) -- generated images from the generator
device (str) -- GPU / CPU: from torch.device('cuda:{}'.format(self.gpu_ids[0])) if self.gpu_ids else torch.device('cpu')
type (str) -- if we mix real and fake data or not [real | fake | mixed].
constant (float) -- the constant used in formula ( | |gradient||_2 - constant)^2
lambda_gp (float) -- weight for this loss
Returns the gradient penalty loss
"""
if lambda_gp > 0.0:
if type == 'real': # either use real images, fake images, or a linear interpolation of two.
interpolatesv = real_data
elif type == 'fake':
interpolatesv = fake_data
elif type == 'mixed':
alpha = torch.rand(real_data.shape[0], 1, device=device)
alpha = alpha.expand(real_data.shape[0], real_data.nelement() // real_data.shape[0]).contiguous().view(*real_data.shape)
interpolatesv = alpha * real_data + ((1 - alpha) * fake_data)
else:
raise NotImplementedError('{} not implemented'.format(type))
interpolatesv.requires_grad_(True)
disc_interpolates = netD(interpolatesv)
gradients = torch.autograd.grad(outputs=disc_interpolates, inputs=interpolatesv,
grad_outputs=torch.ones(disc_interpolates.size()).to(device),
create_graph=True, retain_graph=True, only_inputs=True)
gradients = gradients[0].view(real_data.size(0), -1) # flat the data
gradient_penalty = (((gradients + 1e-16).norm(2, dim=1) - constant) ** 2).mean() * lambda_gp # added eps
return gradient_penalty, gradients
else:
return 0.0, None
class Normalize(nn.Module):
def __init__(self, power=2):
super(Normalize, self).__init__()
self.power = power
def forward(self, x):
norm = x.pow(self.power).sum(1, keepdim=True).pow(1. / self.power)
out = x.div(norm + 1e-7)
return out
class PoolingF(nn.Module):
def __init__(self):
super(PoolingF, self).__init__()
model = [nn.AdaptiveMaxPool2d(1)]
self.model = nn.Sequential(*model)
self.l2norm = Normalize(2)
def forward(self, x):
return self.l2norm(self.model(x))
class ReshapeF(nn.Module):
def __init__(self):
super(ReshapeF, self).__init__()
model = [nn.AdaptiveAvgPool2d(4)]
self.model = nn.Sequential(*model)
self.l2norm = Normalize(2)
def forward(self, x):
x = self.model(x)
x_reshape = x.permute(0, 2, 3, 1).flatten(0, 2)
return self.l2norm(x_reshape)
class StridedConvF(nn.Module):
def __init__(self, init_type='normal', init_gain=0.02, gpu_ids=[]):
super().__init__()
# self.conv1 = nn.Conv2d(256, 128, 3, stride=2)
# self.conv2 = nn.Conv2d(128, 64, 3, stride=1)
self.l2_norm = Normalize(2)
self.mlps = {}
self.moving_averages = {}
self.init_type = init_type
self.init_gain = init_gain
self.gpu_ids = gpu_ids
def create_mlp(self, x):
C, H = x.shape[1], x.shape[2]
n_down = int(np.rint(np.log2(H / 32)))
mlp = []
for i in range(n_down):
mlp.append(nn.Conv2d(C, max(C // 2, 64), 3, stride=2))
mlp.append(nn.ReLU())
C = max(C // 2, 64)
mlp.append(nn.Conv2d(C, 64, 3))
mlp = nn.Sequential(*mlp)
init_net(mlp, self.init_type, self.init_gain, self.gpu_ids)
return mlp
def update_moving_average(self, key, x):
if key not in self.moving_averages:
self.moving_averages[key] = x.detach()
self.moving_averages[key] = self.moving_averages[key] * 0.999 + x.detach() * 0.001
def forward(self, x, use_instance_norm=False):
C, H = x.shape[1], x.shape[2]
key = '%d_%d' % (C, H)
if key not in self.mlps:
self.mlps[key] = self.create_mlp(x)
self.add_module("child_%s" % key, self.mlps[key])
mlp = self.mlps[key]
x = mlp(x)
self.update_moving_average(key, x)
x = x - self.moving_averages[key]
if use_instance_norm:
x = F.instance_norm(x)
return self.l2_norm(x)
class PatchSampleF(nn.Module):
def __init__(self, use_mlp=False, init_type='normal', init_gain=0.02, nc=256, gpu_ids=[]):
# potential issues: currently, we use the same patch_ids for multiple images in the batch
super(PatchSampleF, self).__init__()
self.l2norm = Normalize(2)
self.use_mlp = use_mlp
self.nc = nc # hard-coded
self.mlp_init = False
self.init_type = init_type
self.init_gain = init_gain
self.gpu_ids = gpu_ids
def create_mlp(self, feats):
for mlp_id, feat in enumerate(feats):
input_nc = feat.shape[1]
mlp = nn.Sequential(*[nn.Linear(input_nc, self.nc), nn.ReLU(), nn.Linear(self.nc, self.nc)])
if len(self.gpu_ids) > 0:
mlp.cuda()
setattr(self, 'mlp_%d' % mlp_id, mlp)
init_net(self, self.init_type, self.init_gain, self.gpu_ids)
self.mlp_init = True
def forward(self, feats, num_patches=64, patch_ids=None):
return_ids = []
return_feats = []
if self.use_mlp and not self.mlp_init:
self.create_mlp(feats)
for feat_id, feat in enumerate(feats):
B, H, W = feat.shape[0], feat.shape[2], feat.shape[3]
feat_reshape = feat.permute(0, 2, 3, 1).flatten(1, 2)
if num_patches > 0:
if patch_ids is not None:
patch_id = patch_ids[feat_id]
else:
# torch.randperm produces cudaErrorIllegalAddress for newer versions of PyTorch. https://github.com/taesungp/contrastive-unpaired-translation/issues/83
#patch_id = torch.randperm(feat_reshape.shape[1], device=feats[0].device)
patch_id = np.random.permutation(feat_reshape.shape[1])
patch_id = patch_id[:int(min(num_patches, patch_id.shape[0]))] # .to(patch_ids.device)
patch_id = torch.tensor(patch_id, dtype=torch.long, device=feat.device)
x_sample = feat_reshape[:, patch_id, :].flatten(0, 1) # reshape(-1, x.shape[1])
else:
x_sample = feat_reshape
patch_id = []
if self.use_mlp:
mlp = getattr(self, 'mlp_%d' % feat_id)
x_sample = mlp(x_sample)
return_ids.append(patch_id)
x_sample = self.l2norm(x_sample)
if num_patches == 0:
x_sample = x_sample.permute(0, 2, 1).reshape([B, x_sample.shape[-1], H, W])
return_feats.append(x_sample)
return return_feats, return_ids
class G_Resnet(nn.Module):
def __init__(self, input_nc, output_nc, nz, num_downs, n_res, ngf=64,
norm=None, nl_layer=None):
super(G_Resnet, self).__init__()
n_downsample = num_downs
pad_type = 'reflect'
self.enc_content = ContentEncoder(n_downsample, n_res, input_nc, ngf, norm, nl_layer, pad_type=pad_type)
if nz == 0:
self.dec = Decoder(n_downsample, n_res, self.enc_content.output_dim, output_nc, norm=norm, activ=nl_layer, pad_type=pad_type, nz=nz)
else:
self.dec = Decoder_all(n_downsample, n_res, self.enc_content.output_dim, output_nc, norm=norm, activ=nl_layer, pad_type=pad_type, nz=nz)
def decode(self, content, style=None):
return self.dec(content, style)
def forward(self, image, style=None, nce_layers=[], encode_only=False):
content, feats = self.enc_content(image, nce_layers=nce_layers, encode_only=encode_only)
if encode_only:
return feats
else:
images_recon = self.decode(content, style)
if len(nce_layers) > 0:
return images_recon, feats
else:
return images_recon
##################################################################################
# Encoder and Decoders
##################################################################################
class E_adaIN(nn.Module):
def __init__(self, input_nc, output_nc=1, nef=64, n_layers=4,
norm=None, nl_layer=None, vae=False):
# style encoder
super(E_adaIN, self).__init__()
self.enc_style = StyleEncoder(n_layers, input_nc, nef, output_nc, norm='none', activ='relu', vae=vae)
def forward(self, image):
style = self.enc_style(image)
return style
class StyleEncoder(nn.Module):
def __init__(self, n_downsample, input_dim, dim, style_dim, norm, activ, vae=False):
super(StyleEncoder, self).__init__()
self.vae = vae
self.model = []
self.model += [Conv2dBlock(input_dim, dim, 7, 1, 3, norm=norm, activation=activ, pad_type='reflect')]
for i in range(2):
self.model += [Conv2dBlock(dim, 2 * dim, 4, 2, 1, norm=norm, activation=activ, pad_type='reflect')]
dim *= 2
for i in range(n_downsample - 2):
self.model += [Conv2dBlock(dim, dim, 4, 2, 1, norm=norm, activation=activ, pad_type='reflect')]
self.model += [nn.AdaptiveAvgPool2d(1)] # global average pooling
if self.vae:
self.fc_mean = nn.Linear(dim, style_dim) # , 1, 1, 0)
self.fc_var = nn.Linear(dim, style_dim) # , 1, 1, 0)
else:
self.model += [nn.Conv2d(dim, style_dim, 1, 1, 0)]
self.model = nn.Sequential(*self.model)
self.output_dim = dim
def forward(self, x):
if self.vae:
output = self.model(x)
output = output.view(x.size(0), -1)
output_mean = self.fc_mean(output)
output_var = self.fc_var(output)
return output_mean, output_var
else:
return self.model(x).view(x.size(0), -1)
class ContentEncoder(nn.Module):
def __init__(self, n_downsample, n_res, input_dim, dim, norm, activ, pad_type='zero'):
super(ContentEncoder, self).__init__()
self.model = []
self.model += [Conv2dBlock(input_dim, dim, 7, 1, 3, norm=norm, activation=activ, pad_type='reflect')]
# downsampling blocks
for i in range(n_downsample):
self.model += [Conv2dBlock(dim, 2 * dim, 4, 2, 1, norm=norm, activation=activ, pad_type='reflect')]
dim *= 2
# residual blocks
self.model += [ResBlocks(n_res, dim, norm=norm, activation=activ, pad_type=pad_type)]
self.model = nn.Sequential(*self.model)
self.output_dim = dim
def forward(self, x, nce_layers=[], encode_only=False):
if len(nce_layers) > 0:
feat = x
feats = []
for layer_id, layer in enumerate(self.model):
feat = layer(feat)
if layer_id in nce_layers:
feats.append(feat)
if layer_id == nce_layers[-1] and encode_only:
return None, feats
return feat, feats
else:
return self.model(x), None
for layer_id, layer in enumerate(self.model):
print(layer_id, layer)
class Decoder_all(nn.Module):
def __init__(self, n_upsample, n_res, dim, output_dim, norm='batch', activ='relu', pad_type='zero', nz=0):
super(Decoder_all, self).__init__()
# AdaIN residual blocks
self.resnet_block = ResBlocks(n_res, dim, norm, activ, pad_type=pad_type, nz=nz)
self.n_blocks = 0
# upsampling blocks
for i in range(n_upsample):
block = [Upsample2(scale_factor=2), Conv2dBlock(dim + nz, dim // 2, 5, 1, 2, norm='ln', activation=activ, pad_type='reflect')]
setattr(self, 'block_{:d}'.format(self.n_blocks), nn.Sequential(*block))
self.n_blocks += 1
dim //= 2
# use reflection padding in the last conv layer
setattr(self, 'block_{:d}'.format(self.n_blocks), Conv2dBlock(dim + nz, output_dim, 7, 1, 3, norm='none', activation='tanh', pad_type='reflect'))
self.n_blocks += 1
def forward(self, x, y=None):
if y is not None:
output = self.resnet_block(cat_feature(x, y))
for n in range(self.n_blocks):
block = getattr(self, 'block_{:d}'.format(n))
if n > 0:
output = block(cat_feature(output, y))
else:
output = block(output)
return output
class Decoder(nn.Module):
def __init__(self, n_upsample, n_res, dim, output_dim, norm='batch', activ='relu', pad_type='zero', nz=0):
super(Decoder, self).__init__()
self.model = []
# AdaIN residual blocks
self.model += [ResBlocks(n_res, dim, norm, activ, pad_type=pad_type, nz=nz)]
# upsampling blocks
for i in range(n_upsample):
if i == 0:
input_dim = dim + nz
else:
input_dim = dim
self.model += [Upsample2(scale_factor=2), Conv2dBlock(input_dim, dim // 2, 5, 1, 2, norm='ln', activation=activ, pad_type='reflect')]
dim //= 2
# use reflection padding in the last conv layer
self.model += [Conv2dBlock(dim, output_dim, 7, 1, 3, norm='none', activation='tanh', pad_type='reflect')]
self.model = nn.Sequential(*self.model)
def forward(self, x, y=None):
if y is not None:
return self.model(cat_feature(x, y))
else:
return self.model(x)
##################################################################################
# Sequential Models
##################################################################################
class ResBlocks(nn.Module):
def __init__(self, num_blocks, dim, norm='inst', activation='relu', pad_type='zero', nz=0):
super(ResBlocks, self).__init__()
self.model = []
for i in range(num_blocks):
self.model += [ResBlock(dim, norm=norm, activation=activation, pad_type=pad_type, nz=nz)]
self.model = nn.Sequential(*self.model)
def forward(self, x):
return self.model(x)
##################################################################################
# Basic Blocks
##################################################################################
def cat_feature(x, y):
y_expand = y.view(y.size(0), y.size(1), 1, 1).expand(
y.size(0), y.size(1), x.size(2), x.size(3))
x_cat = torch.cat([x, y_expand], 1)
return x_cat
class ResBlock(nn.Module):
def __init__(self, dim, norm='inst', activation='relu', pad_type='zero', nz=0):
super(ResBlock, self).__init__()
model = []
model += [Conv2dBlock(dim + nz, dim, 3, 1, 1, norm=norm, activation=activation, pad_type=pad_type)]
model += [Conv2dBlock(dim, dim + nz, 3, 1, 1, norm=norm, activation='none', pad_type=pad_type)]
self.model = nn.Sequential(*model)
def forward(self, x):
residual = x
out = self.model(x)
out += residual
return out
class Conv2dBlock(nn.Module):
def __init__(self, input_dim, output_dim, kernel_size, stride,
padding=0, norm='none', activation='relu', pad_type='zero'):
super(Conv2dBlock, self).__init__()
self.use_bias = True
# initialize padding
if pad_type == 'reflect':
self.pad = nn.ReflectionPad2d(padding)
elif pad_type == 'zero':
self.pad = nn.ZeroPad2d(padding)
else:
assert 0, "Unsupported padding type: {}".format(pad_type)
# initialize normalization
norm_dim = output_dim
if norm == 'batch':
self.norm = nn.BatchNorm2d(norm_dim)
elif norm == 'inst':
self.norm = nn.InstanceNorm2d(norm_dim, track_running_stats=False)
elif norm == 'ln':
self.norm = LayerNorm(norm_dim)
elif norm == 'none':
self.norm = None
else:
assert 0, "Unsupported normalization: {}".format(norm)
# initialize activation
if activation == 'relu':
self.activation = nn.ReLU(inplace=True)
elif activation == 'lrelu':
self.activation = nn.LeakyReLU(0.2, inplace=True)
elif activation == 'prelu':
self.activation = nn.PReLU()
elif activation == 'selu':
self.activation = nn.SELU(inplace=True)
elif activation == 'tanh':
self.activation = nn.Tanh()
elif activation == 'none':
self.activation = None
else:
assert 0, "Unsupported activation: {}".format(activation)
# initialize convolution
self.conv = nn.Conv2d(input_dim, output_dim, kernel_size, stride, bias=self.use_bias)
def forward(self, x):
x = self.conv(self.pad(x))
if self.norm:
x = self.norm(x)
if self.activation:
x = self.activation(x)
return x
class LinearBlock(nn.Module):
def __init__(self, input_dim, output_dim, norm='none', activation='relu'):
super(LinearBlock, self).__init__()
use_bias = True
# initialize fully connected layer
self.fc = nn.Linear(input_dim, output_dim, bias=use_bias)
# initialize normalization
norm_dim = output_dim
if norm == 'batch':
self.norm = nn.BatchNorm1d(norm_dim)
elif norm == 'inst':
self.norm = nn.InstanceNorm1d(norm_dim)
elif norm == 'ln':
self.norm = LayerNorm(norm_dim)
elif norm == 'none':
self.norm = None
else:
assert 0, "Unsupported normalization: {}".format(norm)
# initialize activation
if activation == 'relu':
self.activation = nn.ReLU(inplace=True)
elif activation == 'lrelu':
self.activation = nn.LeakyReLU(0.2, inplace=True)
elif activation == 'prelu':
self.activation = nn.PReLU()
elif activation == 'selu':
self.activation = nn.SELU(inplace=True)
elif activation == 'tanh':
self.activation = nn.Tanh()
elif activation == 'none':
self.activation = None
else:
assert 0, "Unsupported activation: {}".format(activation)
def forward(self, x):
out = self.fc(x)
if self.norm:
out = self.norm(out)
if self.activation:
out = self.activation(out)
return out
##################################################################################
# Normalization layers
##################################################################################
class LayerNorm(nn.Module):
def __init__(self, num_features, eps=1e-5, affine=True):
super(LayerNorm, self).__init__()
self.num_features = num_features
self.affine = affine
self.eps = eps
if self.affine:
self.gamma = nn.Parameter(torch.Tensor(num_features).uniform_())
self.beta = nn.Parameter(torch.zeros(num_features))
def forward(self, x):
shape = [-1] + [1] * (x.dim() - 1)
mean = x.view(x.size(0), -1).mean(1).view(*shape)
std = x.view(x.size(0), -1).std(1).view(*shape)
x = (x - mean) / (std + self.eps)
if self.affine:
shape = [1, -1] + [1] * (x.dim() - 2)
x = x * self.gamma.view(*shape) + self.beta.view(*shape)
return x
class ResnetGenerator(nn.Module):
"""Resnet-based generator that consists of Resnet blocks between a few downsampling/upsampling operations.
We adapt Torch code and idea from Justin Johnson's neural style transfer project(https://github.com/jcjohnson/fast-neural-style)
"""
def __init__(self, input_nc, output_nc, ngf=64, norm_layer=nn.BatchNorm2d, use_dropout=False, n_blocks=6, padding_type='reflect', no_antialias=False, no_antialias_up=False, opt=None):
"""Construct a Resnet-based generator
Parameters:
input_nc (int) -- the number of channels in input images
output_nc (int) -- the number of channels in output images
ngf (int) -- the number of filters in the last conv layer
norm_layer -- normalization layer
use_dropout (bool) -- if use dropout layers
n_blocks (int) -- the number of ResNet blocks
padding_type (str) -- the name of padding layer in conv layers: reflect | replicate | zero
"""
assert(n_blocks >= 0)
super(ResnetGenerator, self).__init__()
self.opt = opt
if type(norm_layer) == functools.partial:
use_bias = norm_layer.func == nn.InstanceNorm2d
else:
use_bias = norm_layer == nn.InstanceNorm2d
model = [nn.ReflectionPad2d(3),
nn.Conv2d(input_nc, ngf, kernel_size=7, padding=0, bias=use_bias),
norm_layer(ngf),
nn.ReLU(True)]
n_downsampling = 2
for i in range(n_downsampling): # add downsampling layers
mult = 2 ** i
if(no_antialias):
model += [nn.Conv2d(ngf * mult, ngf * mult * 2, kernel_size=3, stride=2, padding=1, bias=use_bias),
norm_layer(ngf * mult * 2),
nn.ReLU(True)]
else:
model += [nn.Conv2d(ngf * mult, ngf * mult * 2, kernel_size=3, stride=1, padding=1, bias=use_bias),
norm_layer(ngf * mult * 2),
nn.ReLU(True),
Downsample(ngf * mult * 2)]
mult = 2 ** n_downsampling
for i in range(n_blocks): # add ResNet blocks
model += [ResnetBlock(ngf * mult, padding_type=padding_type, norm_layer=norm_layer, use_dropout=use_dropout, use_bias=use_bias)]
for i in range(n_downsampling): # add upsampling layers
mult = 2 ** (n_downsampling - i)
if no_antialias_up:
model += [nn.ConvTranspose2d(ngf * mult, int(ngf * mult / 2),
kernel_size=3, stride=2,
padding=1, output_padding=1,
bias=use_bias),
norm_layer(int(ngf * mult / 2)),
nn.ReLU(True)]
else:
model += [Upsample(ngf * mult),
nn.Conv2d(ngf * mult, int(ngf * mult / 2),
kernel_size=3, stride=1,
padding=1, # output_padding=1,
bias=use_bias),
norm_layer(int(ngf * mult / 2)),
nn.ReLU(True)]
model += [nn.ReflectionPad2d(3)]
model += [nn.Conv2d(ngf, output_nc, kernel_size=7, padding=0)]
model += [nn.Tanh()]
self.model = nn.Sequential(*model)
def forward(self, input, layers=[], encode_only=False):
if -1 in layers:
layers.append(len(self.model))
if len(layers) > 0:
feat = input
feats = []
for layer_id, layer in enumerate(self.model):
# print(layer_id, layer)
feat = layer(feat)
if layer_id in layers:
# print("%d: adding the output of %s %d" % (layer_id, layer.__class__.__name__, feat.size(1)))
feats.append(feat)
else:
# print("%d: skipping %s %d" % (layer_id, layer.__class__.__name__, feat.size(1)))
pass
if layer_id == layers[-1] and encode_only:
# print('encoder only return features')
return feats # return intermediate features alone; stop in the last layers
return feat, feats # return both output and intermediate features
else:
"""Standard forward"""
fake = self.model(input)
return fake
class ResnetDecoder(nn.Module):
"""Resnet-based decoder that consists of a few Resnet blocks + a few upsampling operations.
"""
def __init__(self, input_nc, output_nc, ngf=64, norm_layer=nn.BatchNorm2d, use_dropout=False, n_blocks=6, padding_type='reflect', no_antialias=False):
"""Construct a Resnet-based decoder
Parameters:
input_nc (int) -- the number of channels in input images
output_nc (int) -- the number of channels in output images
ngf (int) -- the number of filters in the last conv layer
norm_layer -- normalization layer
use_dropout (bool) -- if use dropout layers
n_blocks (int) -- the number of ResNet blocks
padding_type (str) -- the name of padding layer in conv layers: reflect | replicate | zero
"""
assert(n_blocks >= 0)
super(ResnetDecoder, self).__init__()
if type(norm_layer) == functools.partial:
use_bias = norm_layer.func == nn.InstanceNorm2d
else:
use_bias = norm_layer == nn.InstanceNorm2d
model = []
n_downsampling = 2
mult = 2 ** n_downsampling
for i in range(n_blocks): # add ResNet blocks
model += [ResnetBlock(ngf * mult, padding_type=padding_type, norm_layer=norm_layer, use_dropout=use_dropout, use_bias=use_bias)]
for i in range(n_downsampling): # add upsampling layers
mult = 2 ** (n_downsampling - i)
if(no_antialias):
model += [nn.ConvTranspose2d(ngf * mult, int(ngf * mult / 2),
kernel_size=3, stride=2,
padding=1, output_padding=1,
bias=use_bias),
norm_layer(int(ngf * mult / 2)),
nn.ReLU(True)]
else:
model += [Upsample(ngf * mult),
nn.Conv2d(ngf * mult, int(ngf * mult / 2),
kernel_size=3, stride=1,
padding=1,
bias=use_bias),
norm_layer(int(ngf * mult / 2)),
nn.ReLU(True)]
model += [nn.ReflectionPad2d(3)]
model += [nn.Conv2d(ngf, output_nc, kernel_size=7, padding=0)]
model += [nn.Tanh()]
self.model = nn.Sequential(*model)
def forward(self, input):
"""Standard forward"""
return self.model(input)
class ResnetEncoder(nn.Module):
"""Resnet-based encoder that consists of a few downsampling + several Resnet blocks
"""
def __init__(self, input_nc, output_nc, ngf=64, norm_layer=nn.BatchNorm2d, use_dropout=False, n_blocks=6, padding_type='reflect', no_antialias=False):
"""Construct a Resnet-based encoder
Parameters:
input_nc (int) -- the number of channels in input images
output_nc (int) -- the number of channels in output images
ngf (int) -- the number of filters in the last conv layer
norm_layer -- normalization layer
use_dropout (bool) -- if use dropout layers
n_blocks (int) -- the number of ResNet blocks
padding_type (str) -- the name of padding layer in conv layers: reflect | replicate | zero
"""
assert(n_blocks >= 0)
super(ResnetEncoder, self).__init__()
if type(norm_layer) == functools.partial:
use_bias = norm_layer.func == nn.InstanceNorm2d
else:
use_bias = norm_layer == nn.InstanceNorm2d
model = [nn.ReflectionPad2d(3),
nn.Conv2d(input_nc, ngf, kernel_size=7, padding=0, bias=use_bias),
norm_layer(ngf),
nn.ReLU(True)]
n_downsampling = 2
for i in range(n_downsampling): # add downsampling layers
mult = 2 ** i
if(no_antialias):
model += [nn.Conv2d(ngf * mult, ngf * mult * 2, kernel_size=3, stride=2, padding=1, bias=use_bias),
norm_layer(ngf * mult * 2),
nn.ReLU(True)]
else:
model += [nn.Conv2d(ngf * mult, ngf * mult * 2, kernel_size=3, stride=1, padding=1, bias=use_bias),
norm_layer(ngf * mult * 2),
nn.ReLU(True),
Downsample(ngf * mult * 2)]
mult = 2 ** n_downsampling
for i in range(n_blocks): # add ResNet blocks
model += [ResnetBlock(ngf * mult, padding_type=padding_type, norm_layer=norm_layer, use_dropout=use_dropout, use_bias=use_bias)]
self.model = nn.Sequential(*model)
def forward(self, input):
"""Standard forward"""
return self.model(input)
class ResnetBlock(nn.Module):
"""Define a Resnet block"""
def __init__(self, dim, padding_type, norm_layer, use_dropout, use_bias):
"""Initialize the Resnet block
A resnet block is a conv block with skip connections
We construct a conv block with build_conv_block function,
and implement skip connections in <forward> function.
Original Resnet paper: https://arxiv.org/pdf/1512.03385.pdf
"""
super(ResnetBlock, self).__init__()
self.conv_block = self.build_conv_block(dim, padding_type, norm_layer, use_dropout, use_bias)
def build_conv_block(self, dim, padding_type, norm_layer, use_dropout, use_bias):
"""Construct a convolutional block.
Parameters:
dim (int) -- the number of channels in the conv layer.
padding_type (str) -- the name of padding layer: reflect | replicate | zero
norm_layer -- normalization layer
use_dropout (bool) -- if use dropout layers.
use_bias (bool) -- if the conv layer uses bias or not
Returns a conv block (with a conv layer, a normalization layer, and a non-linearity layer (ReLU))
"""
conv_block = []
p = 0
if padding_type == 'reflect':
conv_block += [nn.ReflectionPad2d(1)]
elif padding_type == 'replicate':
conv_block += [nn.ReplicationPad2d(1)]
elif padding_type == 'zero':
p = 1
else:
raise NotImplementedError('padding [%s] is not implemented' % padding_type)
conv_block += [nn.Conv2d(dim, dim, kernel_size=3, padding=p, bias=use_bias), norm_layer(dim), nn.ReLU(True)]
if use_dropout:
conv_block += [nn.Dropout(0.5)]
p = 0
if padding_type == 'reflect':
conv_block += [nn.ReflectionPad2d(1)]
elif padding_type == 'replicate':
conv_block += [nn.ReplicationPad2d(1)]
elif padding_type == 'zero':
p = 1
else:
raise NotImplementedError('padding [%s] is not implemented' % padding_type)
conv_block += [nn.Conv2d(dim, dim, kernel_size=3, padding=p, bias=use_bias), norm_layer(dim)]
return nn.Sequential(*conv_block)
def forward(self, x):
"""Forward function (with skip connections)"""
out = x + self.conv_block(x) # add skip connections
return out
class UnetGenerator(nn.Module):
"""Create a Unet-based generator"""
def __init__(self, input_nc, output_nc, num_downs, ngf=64, norm_layer=nn.BatchNorm2d, use_dropout=False):
"""Construct a Unet generator
Parameters:
input_nc (int) -- the number of channels in input images
output_nc (int) -- the number of channels in output images
num_downs (int) -- the number of downsamplings in UNet. For example, # if |num_downs| == 7,
image of size 128x128 will become of size 1x1 # at the bottleneck
ngf (int) -- the number of filters in the last conv layer
norm_layer -- normalization layer
We construct the U-Net from the innermost layer to the outermost layer.
It is a recursive process.
"""
super(UnetGenerator, self).__init__()
# construct unet structure
unet_block = UnetSkipConnectionBlock(ngf * 8, ngf * 8, input_nc=None, submodule=None, norm_layer=norm_layer, innermost=True) # add the innermost layer
for i in range(num_downs - 5): # add intermediate layers with ngf * 8 filters
unet_block = UnetSkipConnectionBlock(ngf * 8, ngf * 8, input_nc=None, submodule=unet_block, norm_layer=norm_layer, use_dropout=use_dropout)
# gradually reduce the number of filters from ngf * 8 to ngf
unet_block = UnetSkipConnectionBlock(ngf * 4, ngf * 8, input_nc=None, submodule=unet_block, norm_layer=norm_layer)
unet_block = UnetSkipConnectionBlock(ngf * 2, ngf * 4, input_nc=None, submodule=unet_block, norm_layer=norm_layer)
unet_block = UnetSkipConnectionBlock(ngf, ngf * 2, input_nc=None, submodule=unet_block, norm_layer=norm_layer)
self.model = UnetSkipConnectionBlock(output_nc, ngf, input_nc=input_nc, submodule=unet_block, outermost=True, norm_layer=norm_layer) # add the outermost layer
def forward(self, input):
"""Standard forward"""
return self.model(input)
class UnetSkipConnectionBlock(nn.Module):
"""Defines the Unet submodule with skip connection.
X -------------------identity----------------------
|-- downsampling -- |submodule| -- upsampling --|
"""
def __init__(self, outer_nc, inner_nc, input_nc=None,
submodule=None, outermost=False, innermost=False, norm_layer=nn.BatchNorm2d, use_dropout=False):
"""Construct a Unet submodule with skip connections.
Parameters:
outer_nc (int) -- the number of filters in the outer conv layer
inner_nc (int) -- the number of filters in the inner conv layer
input_nc (int) -- the number of channels in input images/features
submodule (UnetSkipConnectionBlock) -- previously defined submodules
outermost (bool) -- if this module is the outermost module
innermost (bool) -- if this module is the innermost module
norm_layer -- normalization layer
use_dropout (bool) -- if use dropout layers.
"""
super(UnetSkipConnectionBlock, self).__init__()
self.outermost = outermost
if type(norm_layer) == functools.partial:
use_bias = norm_layer.func == nn.InstanceNorm2d
else:
use_bias = norm_layer == nn.InstanceNorm2d
if input_nc is None:
input_nc = outer_nc
downconv = nn.Conv2d(input_nc, inner_nc, kernel_size=4,
stride=2, padding=1, bias=use_bias)
downrelu = nn.LeakyReLU(0.2, True)
downnorm = norm_layer(inner_nc)
uprelu = nn.ReLU(True)
upnorm = norm_layer(outer_nc)
if outermost:
upconv = nn.ConvTranspose2d(inner_nc * 2, outer_nc,
kernel_size=4, stride=2,
padding=1)
down = [downconv]
up = [uprelu, upconv, nn.Tanh()]
model = down + [submodule] + up
elif innermost:
upconv = nn.ConvTranspose2d(inner_nc, outer_nc,
kernel_size=4, stride=2,
padding=1, bias=use_bias)
down = [downrelu, downconv]
up = [uprelu, upconv, upnorm]
model = down + up
else:
upconv = nn.ConvTranspose2d(inner_nc * 2, outer_nc,
kernel_size=4, stride=2,
padding=1, bias=use_bias)
down = [downrelu, downconv, downnorm]
up = [uprelu, upconv, upnorm]
if use_dropout:
model = down + [submodule] + up + [nn.Dropout(0.5)]
else:
model = down + [submodule] + up
self.model = nn.Sequential(*model)
def forward(self, x):
if self.outermost:
return self.model(x)
else: # add skip connections
return torch.cat([x, self.model(x)], 1)
class NLayerDiscriminator(nn.Module):
"""Defines a PatchGAN discriminator"""
def __init__(self, input_nc, ndf=64, n_layers=3, norm_layer=nn.BatchNorm2d, no_antialias=False):
"""Construct a PatchGAN discriminator
Parameters:
input_nc (int) -- the number of channels in input images
ndf (int) -- the number of filters in the last conv layer
n_layers (int) -- the number of conv layers in the discriminator
norm_layer -- normalization layer
"""
super(NLayerDiscriminator, self).__init__()
if type(norm_layer) == functools.partial: # no need to use bias as BatchNorm2d has affine parameters
use_bias = norm_layer.func == nn.InstanceNorm2d
else:
use_bias = norm_layer == nn.InstanceNorm2d
kw = 4
padw = 1
if(no_antialias):
sequence = [nn.Conv2d(input_nc, ndf, kernel_size=kw, stride=2, padding=padw), nn.LeakyReLU(0.2, True)]
else:
sequence = [nn.Conv2d(input_nc, ndf, kernel_size=kw, stride=1, padding=padw), nn.LeakyReLU(0.2, True), Downsample(ndf)]
nf_mult = 1
nf_mult_prev = 1
for n in range(1, n_layers): # gradually increase the number of filters
nf_mult_prev = nf_mult
nf_mult = min(2 ** n, 8)
if(no_antialias):
sequence += [
nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult, kernel_size=kw, stride=2, padding=padw, bias=use_bias),
norm_layer(ndf * nf_mult),
nn.LeakyReLU(0.2, True)
]
else:
sequence += [
nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult, kernel_size=kw, stride=1, padding=padw, bias=use_bias),
norm_layer(ndf * nf_mult),
nn.LeakyReLU(0.2, True),
Downsample(ndf * nf_mult)]
nf_mult_prev = nf_mult
nf_mult = min(2 ** n_layers, 8)
sequence += [
nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult, kernel_size=kw, stride=1, padding=padw, bias=use_bias),
norm_layer(ndf * nf_mult),
nn.LeakyReLU(0.2, True)
]
sequence += [nn.Conv2d(ndf * nf_mult, 1, kernel_size=kw, stride=1, padding=padw)] # output 1 channel prediction map
self.model = nn.Sequential(*sequence)
def forward(self, input):
"""Standard forward."""
return self.model(input)
class PixelDiscriminator(nn.Module):
"""Defines a 1x1 PatchGAN discriminator (pixelGAN)"""
def __init__(self, input_nc, ndf=64, norm_layer=nn.BatchNorm2d):
"""Construct a 1x1 PatchGAN discriminator
Parameters:
input_nc (int) -- the number of channels in input images
ndf (int) -- the number of filters in the last conv layer
norm_layer -- normalization layer
"""
super(PixelDiscriminator, self).__init__()
if type(norm_layer) == functools.partial: # no need to use bias as BatchNorm2d has affine parameters
use_bias = norm_layer.func == nn.InstanceNorm2d
else:
use_bias = norm_layer == nn.InstanceNorm2d
self.net = [
nn.Conv2d(input_nc, ndf, kernel_size=1, stride=1, padding=0),
nn.LeakyReLU(0.2, True),
nn.Conv2d(ndf, ndf * 2, kernel_size=1, stride=1, padding=0, bias=use_bias),
norm_layer(ndf * 2),
nn.LeakyReLU(0.2, True),
nn.Conv2d(ndf * 2, 1, kernel_size=1, stride=1, padding=0, bias=use_bias)]
self.net = nn.Sequential(*self.net)
def forward(self, input):
"""Standard forward."""
return self.net(input)
class PatchDiscriminator(NLayerDiscriminator):
"""Defines a PatchGAN discriminator"""
def __init__(self, input_nc, ndf=64, n_layers=3, norm_layer=nn.BatchNorm2d, no_antialias=False):
super().__init__(input_nc, ndf, 2, norm_layer, no_antialias)
def forward(self, input):
B, C, H, W = input.size(0), input.size(1), input.size(2), input.size(3)
size = 16
Y = H // size
X = W // size
input = input.view(B, C, Y, size, X, size)
input = input.permute(0, 2, 4, 1, 3, 5).contiguous().view(B * Y * X, C, size, size)
return super().forward(input)
class GroupedChannelNorm(nn.Module):
def __init__(self, num_groups):
super().__init__()
self.num_groups = num_groups
def forward(self, x):
shape = list(x.shape)
new_shape = [shape[0], self.num_groups, shape[1] // self.num_groups] + shape[2:]
x = x.view(*new_shape)
mean = x.mean(dim=2, keepdim=True)
std = x.std(dim=2, keepdim=True)
x_norm = (x - mean) / (std + 1e-7)
return x_norm.view(*shape)
| 60,634 | 42.187322 | 187 | py |
contrastive-unpaired-translation | contrastive-unpaired-translation-master/models/template_model.py | """Model class template
This module provides a template for users to implement custom models.
You can specify '--model template' to use this model.
The class name should be consistent with both the filename and its model option.
The filename should be <model>_dataset.py
The class name should be <Model>Dataset.py
It implements a simple image-to-image translation baseline based on regression loss.
Given input-output pairs (data_A, data_B), it learns a network netG that can minimize the following L1 loss:
min_<netG> ||netG(data_A) - data_B||_1
You need to implement the following functions:
<modify_commandline_options>: Add model-specific options and rewrite default values for existing options.
<__init__>: Initialize this model class.
<set_input>: Unpack input data and perform data pre-processing.
<forward>: Run forward pass. This will be called by both <optimize_parameters> and <test>.
<optimize_parameters>: Update network weights; it will be called in every training iteration.
"""
import torch
from .base_model import BaseModel
from . import networks
class TemplateModel(BaseModel):
@staticmethod
def modify_commandline_options(parser, is_train=True):
"""Add new model-specific options and rewrite default values for existing options.
Parameters:
parser -- the option parser
is_train -- if it is training phase or test phase. You can use this flag to add training-specific or test-specific options.
Returns:
the modified parser.
"""
parser.set_defaults(dataset_mode='aligned') # You can rewrite default values for this model. For example, this model usually uses aligned dataset as its dataset.
if is_train:
parser.add_argument('--lambda_regression', type=float, default=1.0, help='weight for the regression loss') # You can define new arguments for this model.
return parser
def __init__(self, opt):
"""Initialize this model class.
Parameters:
opt -- training/test options
A few things can be done here.
- (required) call the initialization function of BaseModel
- define loss function, visualization images, model names, and optimizers
"""
BaseModel.__init__(self, opt) # call the initialization method of BaseModel
# specify the training losses you want to print out. The program will call base_model.get_current_losses to plot the losses to the console and save them to the disk.
self.loss_names = ['loss_G']
# specify the images you want to save and display. The program will call base_model.get_current_visuals to save and display these images.
self.visual_names = ['data_A', 'data_B', 'output']
# specify the models you want to save to the disk. The program will call base_model.save_networks and base_model.load_networks to save and load networks.
# you can use opt.isTrain to specify different behaviors for training and test. For example, some networks will not be used during test, and you don't need to load them.
self.model_names = ['G']
# define networks; you can use opt.isTrain to specify different behaviors for training and test.
self.netG = networks.define_G(opt.input_nc, opt.output_nc, opt.ngf, opt.netG, gpu_ids=self.gpu_ids)
if self.isTrain: # only defined during training time
# define your loss functions. You can use losses provided by torch.nn such as torch.nn.L1Loss.
# We also provide a GANLoss class "networks.GANLoss". self.criterionGAN = networks.GANLoss().to(self.device)
self.criterionLoss = torch.nn.L1Loss()
# define and initialize optimizers. You can define one optimizer for each network.
# If two networks are updated at the same time, you can use itertools.chain to group them. See cycle_gan_model.py for an example.
self.optimizer = torch.optim.Adam(self.netG.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))
self.optimizers = [self.optimizer]
# Our program will automatically call <model.setup> to define schedulers, load networks, and print networks
def set_input(self, input):
"""Unpack input data from the dataloader and perform necessary pre-processing steps.
Parameters:
input: a dictionary that contains the data itself and its metadata information.
"""
AtoB = self.opt.direction == 'AtoB' # use <direction> to swap data_A and data_B
self.data_A = input['A' if AtoB else 'B'].to(self.device) # get image data A
self.data_B = input['B' if AtoB else 'A'].to(self.device) # get image data B
self.image_paths = input['A_paths' if AtoB else 'B_paths'] # get image paths
def forward(self):
"""Run forward pass. This will be called by both functions <optimize_parameters> and <test>."""
self.output = self.netG(self.data_A) # generate output image given the input data_A
def backward(self):
"""Calculate losses, gradients, and update network weights; called in every training iteration"""
# caculate the intermediate results if necessary; here self.output has been computed during function <forward>
# calculate loss given the input and intermediate results
self.loss_G = self.criterionLoss(self.output, self.data_B) * self.opt.lambda_regression
self.loss_G.backward() # calculate gradients of network G w.r.t. loss_G
def optimize_parameters(self):
"""Update network weights; it will be called in every training iteration."""
self.forward() # first call forward to calculate intermediate results
self.optimizer.zero_grad() # clear network G's existing gradients
self.backward() # calculate gradients for network G
self.optimizer.step() # update gradients for network G
| 5,951 | 58.52 | 177 | py |
contrastive-unpaired-translation | contrastive-unpaired-translation-master/models/cycle_gan_model.py | import torch
import itertools
from util.image_pool import ImagePool
from .base_model import BaseModel
from . import networks
try:
from apex import amp
except ImportError as error:
print(error)
class CycleGANModel(BaseModel):
"""
This class implements the CycleGAN model, for learning image-to-image translation without paired data.
The model training requires '--dataset_mode unaligned' dataset.
By default, it uses a '--netG resnet_9blocks' ResNet generator,
a '--netD basic' discriminator (PatchGAN introduced by pix2pix),
and a least-square GANs objective ('--gan_mode lsgan').
CycleGAN paper: https://arxiv.org/pdf/1703.10593.pdf
"""
@staticmethod
def modify_commandline_options(parser, is_train=True):
"""Add new dataset-specific options, and rewrite default values for existing options.
Parameters:
parser -- original option parser
is_train (bool) -- whether training phase or test phase. You can use this flag to add training-specific or test-specific options.
Returns:
the modified parser.
For CycleGAN, in addition to GAN losses, we introduce lambda_A, lambda_B, and lambda_identity for the following losses.
A (source domain), B (target domain).
Generators: G_A: A -> B; G_B: B -> A.
Discriminators: D_A: G_A(A) vs. B; D_B: G_B(B) vs. A.
Forward cycle loss: lambda_A * ||G_B(G_A(A)) - A|| (Eqn. (2) in the paper)
Backward cycle loss: lambda_B * ||G_A(G_B(B)) - B|| (Eqn. (2) in the paper)
Identity loss (optional): lambda_identity * (||G_A(B) - B|| * lambda_B + ||G_B(A) - A|| * lambda_A) (Sec 5.2 "Photo generation from paintings" in the paper)
Dropout is not used in the original CycleGAN paper.
"""
# parser.set_defaults(no_dropout=True, no_antialias=True, no_antialias_up=True) # default CycleGAN did not use dropout
# parser.set_defaults(no_dropout=True)
if is_train:
parser.add_argument('--lambda_A', type=float, default=10.0, help='weight for cycle loss (A -> B -> A)')
parser.add_argument('--lambda_B', type=float, default=10.0, help='weight for cycle loss (B -> A -> B)')
parser.add_argument('--lambda_identity', type=float, default=0.5, help='use identity mapping. Setting lambda_identity other than 0 has an effect of scaling the weight of the identity mapping loss. For example, if the weight of the identity loss should be 10 times smaller than the weight of the reconstruction loss, please set lambda_identity = 0.1')
return parser
def __init__(self, opt):
"""Initialize the CycleGAN class.
Parameters:
opt (Option class)-- stores all the experiment flags; needs to be a subclass of BaseOptions
"""
BaseModel.__init__(self, opt)
# specify the training losses you want to print out. The training/test scripts will call <BaseModel.get_current_losses>
self.loss_names = ['D_A', 'G_A', 'cycle_A', 'idt_A', 'D_B', 'G_B', 'cycle_B', 'idt_B']
# specify the images you want to save/display. The training/test scripts will call <BaseModel.get_current_visuals>
visual_names_A = ['real_A', 'fake_B', 'rec_A']
visual_names_B = ['real_B', 'fake_A', 'rec_B']
if self.isTrain and self.opt.lambda_identity > 0.0: # if identity loss is used, we also visualize idt_B=G_A(B) ad idt_A=G_A(B)
visual_names_A.append('idt_B')
visual_names_B.append('idt_A')
self.visual_names = visual_names_A + visual_names_B # combine visualizations for A and B
# specify the models you want to save to the disk. The training/test scripts will call <BaseModel.save_networks> and <BaseModel.load_networks>.
if self.isTrain:
self.model_names = ['G_A', 'G_B', 'D_A', 'D_B']
else: # during test time, only load Gs
self.model_names = ['G_A', 'G_B']
# define networks (both Generators and discriminators)
# The naming is different from those used in the paper.
# Code (vs. paper): G_A (G), G_B (F), D_A (D_Y), D_B (D_X)
self.netG_A = networks.define_G(opt.input_nc, opt.output_nc, opt.ngf, opt.netG, opt.normG,
not opt.no_dropout, opt.init_type, opt.init_gain, opt.no_antialias, opt.no_antialias_up, self.gpu_ids, opt=opt)
self.netG_B = networks.define_G(opt.output_nc, opt.input_nc, opt.ngf, opt.netG, opt.normG,
not opt.no_dropout, opt.init_type, opt.init_gain, opt.no_antialias, opt.no_antialias_up, self.gpu_ids, opt=opt)
if self.isTrain: # define discriminators
self.netD_A = networks.define_D(opt.output_nc, opt.ndf, opt.netD,
opt.n_layers_D, opt.normD, opt.init_type, opt.init_gain, opt.no_antialias, self.gpu_ids, opt=opt)
self.netD_B = networks.define_D(opt.input_nc, opt.ndf, opt.netD,
opt.n_layers_D, opt.normD, opt.init_type, opt.init_gain, opt.no_antialias, self.gpu_ids, opt=opt)
if self.isTrain:
if opt.lambda_identity > 0.0: # only works when input and output images have the same number of channels
assert(opt.input_nc == opt.output_nc)
self.fake_A_pool = ImagePool(opt.pool_size) # create image buffer to store previously generated images
self.fake_B_pool = ImagePool(opt.pool_size) # create image buffer to store previously generated images
# define loss functions
self.criterionGAN = networks.GANLoss(opt.gan_mode).to(self.device) # define GAN loss.
self.criterionCycle = torch.nn.L1Loss()
self.criterionIdt = torch.nn.L1Loss()
# initialize optimizers; schedulers will be automatically created by function <BaseModel.setup>.
self.optimizer_G = torch.optim.Adam(itertools.chain(self.netG_A.parameters(), self.netG_B.parameters()), lr=opt.lr, betas=(opt.beta1, 0.999))
self.optimizer_D = torch.optim.Adam(itertools.chain(self.netD_A.parameters(), self.netD_B.parameters()), lr=opt.lr, betas=(opt.beta1, 0.999))
self.optimizers.append(self.optimizer_G)
self.optimizers.append(self.optimizer_D)
def set_input(self, input):
"""Unpack input data from the dataloader and perform necessary pre-processing steps.
Parameters:
input (dict): include the data itself and its metadata information.
The option 'direction' can be used to swap domain A and domain B.
"""
AtoB = self.opt.direction == 'AtoB'
self.real_A = input['A' if AtoB else 'B'].to(self.device)
self.real_B = input['B' if AtoB else 'A'].to(self.device)
self.image_paths = input['A_paths' if AtoB else 'B_paths']
def forward(self):
"""Run forward pass; called by both functions <optimize_parameters> and <test>."""
self.fake_B = self.netG_A(self.real_A) # G_A(A)
self.rec_A = self.netG_B(self.fake_B) # G_B(G_A(A))
self.fake_A = self.netG_B(self.real_B) # G_B(B)
self.rec_B = self.netG_A(self.fake_A) # G_A(G_B(B))
def backward_D_basic(self, netD, real, fake):
"""Calculate GAN loss for the discriminator
Parameters:
netD (network) -- the discriminator D
real (tensor array) -- real images
fake (tensor array) -- images generated by a generator
Return the discriminator loss.
We also call loss_D.backward() to calculate the gradients.
"""
# Real
pred_real = netD(real)
loss_D_real = self.criterionGAN(pred_real, True)
# Fake
pred_fake = netD(fake.detach())
loss_D_fake = self.criterionGAN(pred_fake, False)
# Combined loss and calculate gradients
loss_D = (loss_D_real + loss_D_fake) * 0.5
if self.opt.amp:
with amp.scale_loss(loss_D, self.optimizer_D) as scaled_loss:
scaled_loss.backward()
else:
loss_D.backward()
return loss_D
def backward_D_A(self):
"""Calculate GAN loss for discriminator D_A"""
fake_B = self.fake_B_pool.query(self.fake_B)
self.loss_D_A = self.backward_D_basic(self.netD_A, self.real_B, fake_B)
def backward_D_B(self):
"""Calculate GAN loss for discriminator D_B"""
fake_A = self.fake_A_pool.query(self.fake_A)
self.loss_D_B = self.backward_D_basic(self.netD_B, self.real_A, fake_A)
def backward_G(self):
"""Calculate the loss for generators G_A and G_B"""
lambda_idt = self.opt.lambda_identity
lambda_A = self.opt.lambda_A
lambda_B = self.opt.lambda_B
# Identity loss
if lambda_idt > 0:
# G_A should be identity if real_B is fed: ||G_A(B) - B||
self.idt_A = self.netG_A(self.real_B)
self.loss_idt_A = self.criterionIdt(self.idt_A, self.real_B) * lambda_B * lambda_idt
# G_B should be identity if real_A is fed: ||G_B(A) - A||
self.idt_B = self.netG_B(self.real_A)
self.loss_idt_B = self.criterionIdt(self.idt_B, self.real_A) * lambda_A * lambda_idt
else:
self.loss_idt_A = 0
self.loss_idt_B = 0
# GAN loss D_A(G_A(A))
self.loss_G_A = self.criterionGAN(self.netD_A(self.fake_B), True)
# GAN loss D_B(G_B(B))
self.loss_G_B = self.criterionGAN(self.netD_B(self.fake_A), True)
# Forward cycle loss || G_B(G_A(A)) - A||
self.loss_cycle_A = self.criterionCycle(self.rec_A, self.real_A) * lambda_A
# Backward cycle loss || G_A(G_B(B)) - B||
self.loss_cycle_B = self.criterionCycle(self.rec_B, self.real_B) * lambda_B
# combined loss and calculate gradients
self.loss_G = self.loss_G_A + self.loss_G_B + self.loss_cycle_A + self.loss_cycle_B + self.loss_idt_A + self.loss_idt_B
if self.opt.amp:
with amp.scale_loss(self.loss_G, self.optimizer_G) as scaled_loss:
scaled_loss.backward()
else:
self.loss_G.backward()
def data_dependent_initialize(self):
return
def generate_visuals_for_evaluation(self, data, mode):
with torch.no_grad():
visuals = {}
AtoB = self.opt.direction == "AtoB"
G = self.netG_A
source = data["A" if AtoB else "B"].to(self.device)
if mode == "forward":
visuals["fake_B"] = G(source)
else:
raise ValueError("mode %s is not recognized" % mode)
return visuals
def optimize_parameters(self):
"""Calculate losses, gradients, and update network weights; called in every training iteration"""
# forward
self.forward() # compute fake images and reconstruction images.
# G_A and G_B
self.set_requires_grad([self.netD_A, self.netD_B], False) # Ds require no gradients when optimizing Gs
self.optimizer_G.zero_grad() # set G_A and G_B's gradients to zero
self.backward_G() # calculate gradients for G_A and G_B
self.optimizer_G.step() # update G_A and G_B's weights
# D_A and D_B
self.set_requires_grad([self.netD_A, self.netD_B], True)
self.optimizer_D.zero_grad() # set D_A and D_B's gradients to zero
self.backward_D_A() # calculate gradients for D_A
self.backward_D_B() # calculate graidents for D_B
self.optimizer_D.step() # update D_A and D_B's weights
| 11,700 | 51.470852 | 362 | py |
contrastive-unpaired-translation | contrastive-unpaired-translation-master/util/image_pool.py | import random
import torch
class ImagePool():
"""This class implements an image buffer that stores previously generated images.
This buffer enables us to update discriminators using a history of generated images
rather than the ones produced by the latest generators.
"""
def __init__(self, pool_size):
"""Initialize the ImagePool class
Parameters:
pool_size (int) -- the size of image buffer, if pool_size=0, no buffer will be created
"""
self.pool_size = pool_size
if self.pool_size > 0: # create an empty pool
self.num_imgs = 0
self.images = []
def query(self, images):
"""Return an image from the pool.
Parameters:
images: the latest generated images from the generator
Returns images from the buffer.
By 50/100, the buffer will return input images.
By 50/100, the buffer will return images previously stored in the buffer,
and insert the current images to the buffer.
"""
if self.pool_size == 0: # if the buffer size is 0, do nothing
return images
return_images = []
for image in images:
image = torch.unsqueeze(image.data, 0)
if self.num_imgs < self.pool_size: # if the buffer is not full; keep inserting current images to the buffer
self.num_imgs = self.num_imgs + 1
self.images.append(image)
return_images.append(image)
else:
p = random.uniform(0, 1)
if p > 0.5: # by 50% chance, the buffer will return a previously stored image, and insert the current image into the buffer
random_id = random.randint(0, self.pool_size - 1) # randint is inclusive
tmp = self.images[random_id].clone()
self.images[random_id] = image
return_images.append(tmp)
else: # by another 50% chance, the buffer will return the current image
return_images.append(image)
return_images = torch.cat(return_images, 0) # collect all the images and return
return return_images
| 2,226 | 39.490909 | 140 | py |
contrastive-unpaired-translation | contrastive-unpaired-translation-master/util/util.py | """This module contains simple helper functions """
from __future__ import print_function
import torch
import numpy as np
from PIL import Image
import os
import importlib
import argparse
from argparse import Namespace
import torchvision
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 copyconf(default_opt, **kwargs):
conf = Namespace(**vars(default_opt))
for key in kwargs:
setattr(conf, key, kwargs[key])
return conf
def find_class_in_module(target_cls_name, module):
target_cls_name = target_cls_name.replace('_', '').lower()
clslib = importlib.import_module(module)
cls = None
for name, clsobj in clslib.__dict__.items():
if name.lower() == target_cls_name:
cls = clsobj
assert cls is not None, "In %s, there should be a class whose name matches %s in lowercase without underscore(_)" % (module, target_cls_name)
return cls
def tensor2im(input_image, imtype=np.uint8):
""""Converts a Tensor array into a numpy image array.
Parameters:
input_image (tensor) -- the input image tensor array
imtype (type) -- the desired type of the converted numpy array
"""
if not isinstance(input_image, np.ndarray):
if isinstance(input_image, torch.Tensor): # get the data from a variable
image_tensor = input_image.data
else:
return input_image
image_numpy = image_tensor[0].clamp(-1.0, 1.0).cpu().float().numpy() # convert it into a numpy array
if image_numpy.shape[0] == 1: # grayscale to RGB
image_numpy = np.tile(image_numpy, (3, 1, 1))
image_numpy = (np.transpose(image_numpy, (1, 2, 0)) + 1) / 2.0 * 255.0 # post-processing: tranpose and scaling
else: # if it is a numpy array, do nothing
image_numpy = input_image
return image_numpy.astype(imtype)
def diagnose_network(net, name='network'):
"""Calculate and print the mean of average absolute(gradients)
Parameters:
net (torch network) -- Torch network
name (str) -- the name of the network
"""
mean = 0.0
count = 0
for param in net.parameters():
if param.grad is not None:
mean += torch.mean(torch.abs(param.grad.data))
count += 1
if count > 0:
mean = mean / count
print(name)
print(mean)
def save_image(image_numpy, image_path, aspect_ratio=1.0):
"""Save a numpy image to the disk
Parameters:
image_numpy (numpy array) -- input numpy array
image_path (str) -- the path of the image
"""
image_pil = Image.fromarray(image_numpy)
h, w, _ = image_numpy.shape
if aspect_ratio is None:
pass
elif aspect_ratio > 1.0:
image_pil = image_pil.resize((h, int(w * aspect_ratio)), Image.BICUBIC)
elif aspect_ratio < 1.0:
image_pil = image_pil.resize((int(h / aspect_ratio), w), Image.BICUBIC)
image_pil.save(image_path)
def print_numpy(x, val=True, shp=False):
"""Print the mean, min, max, median, std, and size of a numpy array
Parameters:
val (bool) -- if print the values of the numpy array
shp (bool) -- if print the shape of the numpy array
"""
x = x.astype(np.float64)
if shp:
print('shape,', x.shape)
if val:
x = x.flatten()
print('mean = %3.3f, min = %3.3f, max = %3.3f, median = %3.3f, std=%3.3f' % (
np.mean(x), np.min(x), np.max(x), np.median(x), np.std(x)))
def mkdirs(paths):
"""create empty directories if they don't exist
Parameters:
paths (str list) -- a list of directory paths
"""
if isinstance(paths, list) and not isinstance(paths, str):
for path in paths:
mkdir(path)
else:
mkdir(paths)
def mkdir(path):
"""create a single empty directory if it didn't exist
Parameters:
path (str) -- a single directory path
"""
if not os.path.exists(path):
os.makedirs(path)
def correct_resize_label(t, size):
device = t.device
t = t.detach().cpu()
resized = []
for i in range(t.size(0)):
one_t = t[i, :1]
one_np = np.transpose(one_t.numpy().astype(np.uint8), (1, 2, 0))
one_np = one_np[:, :, 0]
one_image = Image.fromarray(one_np).resize(size, Image.NEAREST)
resized_t = torch.from_numpy(np.array(one_image)).long()
resized.append(resized_t)
return torch.stack(resized, dim=0).to(device)
def correct_resize(t, size, mode=Image.BICUBIC):
device = t.device
t = t.detach().cpu()
resized = []
for i in range(t.size(0)):
one_t = t[i:i + 1]
one_image = Image.fromarray(tensor2im(one_t)).resize(size, Image.BICUBIC)
resized_t = torchvision.transforms.functional.to_tensor(one_image) * 2 - 1.0
resized.append(resized_t)
return torch.stack(resized, dim=0).to(device)
| 5,135 | 29.754491 | 145 | py |
contrastive-unpaired-translation | contrastive-unpaired-translation-master/data/base_dataset.py | """This module implements an abstract base class (ABC) 'BaseDataset' for datasets.
It also includes common transformation functions (e.g., get_transform, __scale_width), which can be later used in subclasses.
"""
import random
import numpy as np
import torch.utils.data as data
from PIL import Image
import torchvision.transforms as transforms
from abc import ABC, abstractmethod
class BaseDataset(data.Dataset, ABC):
"""This class is an abstract base class (ABC) for datasets.
To create a subclass, you need to implement the following four functions:
-- <__init__>: initialize the class, first call BaseDataset.__init__(self, opt).
-- <__len__>: return the size of dataset.
-- <__getitem__>: get a data point.
-- <modify_commandline_options>: (optionally) add dataset-specific options and set default options.
"""
def __init__(self, opt):
"""Initialize the class; save the options in the class
Parameters:
opt (Option class)-- stores all the experiment flags; needs to be a subclass of BaseOptions
"""
self.opt = opt
self.root = opt.dataroot
self.current_epoch = 0
@staticmethod
def modify_commandline_options(parser, is_train):
"""Add new dataset-specific options, and rewrite default values for existing options.
Parameters:
parser -- original option parser
is_train (bool) -- whether training phase or test phase. You can use this flag to add training-specific or test-specific options.
Returns:
the modified parser.
"""
return parser
@abstractmethod
def __len__(self):
"""Return the total number of images in the dataset."""
return 0
@abstractmethod
def __getitem__(self, index):
"""Return a data point and its metadata information.
Parameters:
index - - a random integer for data indexing
Returns:
a dictionary of data with their names. It ususally contains the data itself and its metadata information.
"""
pass
def get_params(opt, size):
w, h = size
new_h = h
new_w = w
if opt.preprocess == 'resize_and_crop':
new_h = new_w = opt.load_size
elif opt.preprocess == 'scale_width_and_crop':
new_w = opt.load_size
new_h = opt.load_size * h // w
x = random.randint(0, np.maximum(0, new_w - opt.crop_size))
y = random.randint(0, np.maximum(0, new_h - opt.crop_size))
flip = random.random() > 0.5
return {'crop_pos': (x, y), 'flip': flip}
def get_transform(opt, params=None, grayscale=False, method=Image.BICUBIC, convert=True):
transform_list = []
if grayscale:
transform_list.append(transforms.Grayscale(1))
if 'fixsize' in opt.preprocess:
transform_list.append(transforms.Resize(params["size"], method))
if 'resize' in opt.preprocess:
osize = [opt.load_size, opt.load_size]
if "gta2cityscapes" in opt.dataroot:
osize[0] = opt.load_size // 2
transform_list.append(transforms.Resize(osize, method))
elif 'scale_width' in opt.preprocess:
transform_list.append(transforms.Lambda(lambda img: __scale_width(img, opt.load_size, opt.crop_size, method)))
elif 'scale_shortside' in opt.preprocess:
transform_list.append(transforms.Lambda(lambda img: __scale_shortside(img, opt.load_size, opt.crop_size, method)))
if 'zoom' in opt.preprocess:
if params is None:
transform_list.append(transforms.Lambda(lambda img: __random_zoom(img, opt.load_size, opt.crop_size, method)))
else:
transform_list.append(transforms.Lambda(lambda img: __random_zoom(img, opt.load_size, opt.crop_size, method, factor=params["scale_factor"])))
if 'crop' in opt.preprocess:
if params is None or 'crop_pos' not in params:
transform_list.append(transforms.RandomCrop(opt.crop_size))
else:
transform_list.append(transforms.Lambda(lambda img: __crop(img, params['crop_pos'], opt.crop_size)))
if 'patch' in opt.preprocess:
transform_list.append(transforms.Lambda(lambda img: __patch(img, params['patch_index'], opt.crop_size)))
if 'trim' in opt.preprocess:
transform_list.append(transforms.Lambda(lambda img: __trim(img, opt.crop_size)))
# if opt.preprocess == 'none':
transform_list.append(transforms.Lambda(lambda img: __make_power_2(img, base=4, method=method)))
if not opt.no_flip:
if params is None or 'flip' not in params:
transform_list.append(transforms.RandomHorizontalFlip())
elif 'flip' in params:
transform_list.append(transforms.Lambda(lambda img: __flip(img, params['flip'])))
if convert:
transform_list += [transforms.ToTensor()]
if grayscale:
transform_list += [transforms.Normalize((0.5,), (0.5,))]
else:
transform_list += [transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]
return transforms.Compose(transform_list)
def __make_power_2(img, base, method=Image.BICUBIC):
ow, oh = img.size
h = int(round(oh / base) * base)
w = int(round(ow / base) * base)
if h == oh and w == ow:
return img
return img.resize((w, h), method)
def __random_zoom(img, target_width, crop_width, method=Image.BICUBIC, factor=None):
if factor is None:
zoom_level = np.random.uniform(0.8, 1.0, size=[2])
else:
zoom_level = (factor[0], factor[1])
iw, ih = img.size
zoomw = max(crop_width, iw * zoom_level[0])
zoomh = max(crop_width, ih * zoom_level[1])
img = img.resize((int(round(zoomw)), int(round(zoomh))), method)
return img
def __scale_shortside(img, target_width, crop_width, method=Image.BICUBIC):
ow, oh = img.size
shortside = min(ow, oh)
if shortside >= target_width:
return img
else:
scale = target_width / shortside
return img.resize((round(ow * scale), round(oh * scale)), method)
def __trim(img, trim_width):
ow, oh = img.size
if ow > trim_width:
xstart = np.random.randint(ow - trim_width)
xend = xstart + trim_width
else:
xstart = 0
xend = ow
if oh > trim_width:
ystart = np.random.randint(oh - trim_width)
yend = ystart + trim_width
else:
ystart = 0
yend = oh
return img.crop((xstart, ystart, xend, yend))
def __scale_width(img, target_width, crop_width, method=Image.BICUBIC):
ow, oh = img.size
if ow == target_width and oh >= crop_width:
return img
w = target_width
h = int(max(target_width * oh / ow, crop_width))
return img.resize((w, h), method)
def __crop(img, pos, size):
ow, oh = img.size
x1, y1 = pos
tw = th = size
if (ow > tw or oh > th):
return img.crop((x1, y1, x1 + tw, y1 + th))
return img
def __patch(img, index, size):
ow, oh = img.size
nw, nh = ow // size, oh // size
roomx = ow - nw * size
roomy = oh - nh * size
startx = np.random.randint(int(roomx) + 1)
starty = np.random.randint(int(roomy) + 1)
index = index % (nw * nh)
ix = index // nh
iy = index % nh
gridx = startx + ix * size
gridy = starty + iy * size
return img.crop((gridx, gridy, gridx + size, gridy + size))
def __flip(img, flip):
if flip:
return img.transpose(Image.FLIP_LEFT_RIGHT)
return img
def __print_size_warning(ow, oh, w, h):
"""Print warning information about image size(only print once)"""
if not hasattr(__print_size_warning, 'has_printed'):
print("The image size needs to be a multiple of 4. "
"The loaded image size was (%d, %d), so it was adjusted to "
"(%d, %d). This adjustment will be done to all images "
"whose sizes are not multiples of 4" % (ow, oh, w, h))
__print_size_warning.has_printed = True
| 8,026 | 33.748918 | 153 | py |
contrastive-unpaired-translation | contrastive-unpaired-translation-master/data/image_folder.py | """A modified image folder class
We modify the official PyTorch image folder (https://github.com/pytorch/vision/blob/master/torchvision/datasets/folder.py)
so that this class can load images from both current directory and its subdirectories.
"""
import torch.utils.data as data
from PIL import Image
import os
import os.path
IMG_EXTENSIONS = [
'.jpg', '.JPG', '.jpeg', '.JPEG',
'.png', '.PNG', '.ppm', '.PPM', '.bmp', '.BMP',
'.tif', '.TIF', '.tiff', '.TIFF',
]
def is_image_file(filename):
return any(filename.endswith(extension) for extension in IMG_EXTENSIONS)
def make_dataset(dir, max_dataset_size=float("inf")):
images = []
assert os.path.isdir(dir) or os.path.islink(dir), '%s is not a valid directory' % dir
for root, _, fnames in sorted(os.walk(dir, followlinks=True)):
for fname in fnames:
if is_image_file(fname):
path = os.path.join(root, fname)
images.append(path)
return images[:min(max_dataset_size, len(images))]
def default_loader(path):
return Image.open(path).convert('RGB')
class ImageFolder(data.Dataset):
def __init__(self, root, transform=None, return_paths=False,
loader=default_loader):
imgs = make_dataset(root)
if len(imgs) == 0:
raise(RuntimeError("Found 0 images in: " + root + "\n"
"Supported image extensions are: " + ",".join(IMG_EXTENSIONS)))
self.root = root
self.imgs = imgs
self.transform = transform
self.return_paths = return_paths
self.loader = loader
def __getitem__(self, index):
path = self.imgs[index]
img = self.loader(path)
if self.transform is not None:
img = self.transform(img)
if self.return_paths:
return img, path
else:
return img
def __len__(self):
return len(self.imgs)
| 1,941 | 27.985075 | 122 | py |
contrastive-unpaired-translation | contrastive-unpaired-translation-master/data/__init__.py | """This package includes all the modules related to data loading and preprocessing
To add a custom dataset class called 'dummy', you need to add a file called 'dummy_dataset.py' and define a subclass 'DummyDataset' inherited from BaseDataset.
You need to implement four functions:
-- <__init__>: initialize the class, first call BaseDataset.__init__(self, opt).
-- <__len__>: return the size of dataset.
-- <__getitem__>: get a data point from data loader.
-- <modify_commandline_options>: (optionally) add dataset-specific options and set default options.
Now you can use the dataset class by specifying flag '--dataset_mode dummy'.
See our template dataset class 'template_dataset.py' for more details.
"""
import importlib
import torch.utils.data
from data.base_dataset import BaseDataset
def find_dataset_using_name(dataset_name):
"""Import the module "data/[dataset_name]_dataset.py".
In the file, the class called DatasetNameDataset() will
be instantiated. It has to be a subclass of BaseDataset,
and it is case-insensitive.
"""
dataset_filename = "data." + dataset_name + "_dataset"
datasetlib = importlib.import_module(dataset_filename)
dataset = None
target_dataset_name = dataset_name.replace('_', '') + 'dataset'
for name, cls in datasetlib.__dict__.items():
if name.lower() == target_dataset_name.lower() \
and issubclass(cls, BaseDataset):
dataset = cls
if dataset is None:
raise NotImplementedError("In %s.py, there should be a subclass of BaseDataset with class name that matches %s in lowercase." % (dataset_filename, target_dataset_name))
return dataset
def get_option_setter(dataset_name):
"""Return the static method <modify_commandline_options> of the dataset class."""
dataset_class = find_dataset_using_name(dataset_name)
return dataset_class.modify_commandline_options
def create_dataset(opt):
"""Create a dataset given the option.
This function wraps the class CustomDatasetDataLoader.
This is the main interface between this package and 'train.py'/'test.py'
Example:
>>> from data import create_dataset
>>> dataset = create_dataset(opt)
"""
data_loader = CustomDatasetDataLoader(opt)
dataset = data_loader.load_data()
return dataset
class CustomDatasetDataLoader():
"""Wrapper class of Dataset class that performs multi-threaded data loading"""
def __init__(self, opt):
"""Initialize this class
Step 1: create a dataset instance given the name [dataset_mode]
Step 2: create a multi-threaded data loader.
"""
self.opt = opt
dataset_class = find_dataset_using_name(opt.dataset_mode)
self.dataset = dataset_class(opt)
print("dataset [%s] was created" % type(self.dataset).__name__)
self.dataloader = torch.utils.data.DataLoader(
self.dataset,
batch_size=opt.batch_size,
shuffle=not opt.serial_batches,
num_workers=int(opt.num_threads),
drop_last=True if opt.isTrain else False,
)
def set_epoch(self, epoch):
self.dataset.current_epoch = epoch
def load_data(self):
return self
def __len__(self):
"""Return the number of data in the dataset"""
return min(len(self.dataset), self.opt.max_dataset_size)
def __iter__(self):
"""Return a batch of data"""
for i, data in enumerate(self.dataloader):
if i * self.opt.batch_size >= self.opt.max_dataset_size:
break
yield data
| 3,694 | 36.323232 | 176 | py |
MultilayerBlockModels | MultilayerBlockModels-main/code/run_experiment.py | import argparse
import json
import os
import time
from collections import defaultdict
import numpy as np
import pandas as pd
from model import fit_mlplbm
parser = argparse.ArgumentParser()
parser.add_argument(
'--input_file',
required=True,
help='Path to the input CSV file. '
'Each line of the file represents one edge with the three '
'following fields: top_node, bottom_node, edge_type.'
)
parser.add_argument(
'--output_dir',
default=None,
help='Path to the directory where the results should be written. '
'If None, then the results are written in the current '
'working directory. '
'(default: None)'
)
parser.add_argument(
'--H',
type=int,
nargs='+',
default=list(range(2, 17)),
help='Possible values for the number of top clusters. '
'(default: [2, ..., 16])'
)
parser.add_argument(
'--K',
type=int,
nargs='+',
default=list(range(2, 17)),
help='Possible values for the number of bottom clusters. '
'(default: [2, ..., 16])'
)
parser.add_argument(
'--runs',
type=int,
default=50,
help='Number of runs of the inference procedure to perform for '
'each possible model. '
'Different initial parameters are used for each run, and '
'the best-performing model is returned. '
'(default: 50)'
)
parser.add_argument(
'--epsilon',
type=float,
default=1e-7,
help='Stopping criterion for the inference procedure. '
'(default: 1e-7)'
)
parser.add_argument(
'--max_iter',
type=int,
default=2000,
help='Maximum number of iterations for the inference procedure. '
'(default: 2000)'
)
parser.add_argument(
'--jobs',
type=int,
default=1,
help='Number of parallel workers for the inference procedure. '
'(default: 1)'
)
parser.add_argument(
'--backend',
default='numpy',
help='Backend to use for the computations. '
'Possible values: numpy, torch. '
'(default: "numpy")'
)
parser.add_argument(
'--device',
nargs='+',
default=['cuda'],
help='Identifiers of the devices used by PyTorch. '
'If the number of devices is greater than the number of '
'jobs, than only the first n_jobs devices are used. '
'(default: ["cuda"])'
)
parser.add_argument(
'--verbose',
type=int,
default=1,
help='Level of verbosity (0, 1 or >1). (default: 1)'
)
parser.add_argument(
'--seed',
type=int,
default=None,
help='Random seed for the RNG. '
'If None, the seed is not set. (default: None)'
)
args = parser.parse_args()
df = pd.read_csv(args.input_file)
X = df.to_numpy()
est = fit_mlplbm(
X,
H=args.H,
K=args.K,
runs=args.runs,
epsilon=args.epsilon,
max_iter=args.max_iter,
verbose=args.verbose,
backend=args.backend,
device=args.device,
n_jobs=args.jobs,
random_state=args.seed
)
top, bottom, thetas = est.get_results()
top_clust = dict(
zip(
[u for x in top for u in x],
[h for h, x in enumerate(top) for i in x]
)
)
bottom_clust = dict(
zip(
[v for x in bottom for v in x],
[k for k, x in enumerate(bottom) for j in x]
)
)
df['top_clust'] = df['top'].apply(lambda x: top_clust[x])
df['bottom_clust'] = df['bottom'].apply(lambda x: bottom_clust[x])
cnt = df.groupby(['top_clust', 'bottom_clust', 'type']).sum()
tmp = cnt.to_dict()['count']
counts = {}
for t in thetas:
counts[t] = [
[
tmp[(h, k, t)] if (h, k, t) in tmp else 0
for k in range(est.K)
]
for h in range(est.H)
]
res = {
'top': top,
'bottom': bottom,
'thetas': thetas,
'counts': counts
}
fname = 'results_%d.json' % int(time.time())
if args.output_dir is not None:
if not os.path.exists(args.output_dir):
os.makedirs(args.output_dir)
fp = os.path.join(args.output_dir, fname)
else:
fp = fname
with open(fp, 'w') as out:
out.write(json.dumps(res))
| 3,647 | 20.209302 | 67 | py |
MultilayerBlockModels | MultilayerBlockModels-main/code/utils.py | import numpy as np
try:
import torch
except ModuleNotFoundError:
print('Torch backend unavailable (missing dependencies)')
from scipy.sparse import csr_matrix
MARGIN = 1e-10
def round_prob(C):
'''
Infers the most likely clusters from an array of soft cluster
assignments and returns them as a list of lists.
Arguments
---------
C : array of shape (n_nodes, n_clusters)
Soft cluster assignments.
Returns
-------
clusters : list
List of lists representing the inferred clusters.
The i-th list contains the indices of the nodes belonging to
the i-th cluster.
'''
B = np.argmax(C, 1)
return [np.where(B==i)[0].tolist() for i in range(C.shape[1])]
def safediv(X, Y):
'''
Safe division (avoids division by zero).
Arguments
---------
X : scalar, array or tensor
Dividend.
Y : scalar, array or tensor
Divisor.
Returns
-------
ratio : scalar, array or tensor
Result of the division.
'''
return X/(Y + MARGIN)
def safelog(X, backend='numpy'):
'''
Safe logarithm (avoids zero values inside the log).
Arguments
---------
X : scalar, array or tensor
Argument of the logarithm.
backend : str, default='numpy'
Backend to use.
Should be 'numpy' if X is an array and 'torch' if X is a
tensor.
Returns
-------
log : scalar, array or tensor
Logarithm of X.
'''
if backend == 'numpy':
return np.log(np.fmax(X, MARGIN))
else:
return torch.log(torch.fmax(X, X.new_full((1,), MARGIN)))
def sparse_block_matrix(C):
'''
Transforms a list of clusters into a compressed sparse row matrix
representing the cluster assignments.
Arguments
---------
C : list
List of lists representing the clusters.
The i-th list contains the indices of the nodes belonging to
the i-th cluster.
Returns
-------
matrix : sparse matrix of shape (n_nodes, n_clusters)
Binary cluster assignment matrix.
'''
n_nodes = sum(len(c) for c in C)
idx = np.array([
(i, j) for j, c in enumerate(C) for i in c
])
Cm = csr_matrix(
(
np.ones(n_nodes),
(idx[:, 0], idx[:, 1])
),
shape=(n_nodes, len(C))
)
return Cm | 2,083 | 16.965517 | 66 | py |
MultilayerBlockModels | MultilayerBlockModels-main/code/model.py | import time
import numpy as np
try:
import torch
from torch_sparse import transpose, spmm
except ModuleNotFoundError:
print('Torch backend unavailable (missing dependencies)')
from scipy.sparse import csr_matrix
from scipy.stats import entropy
from sklearn.base import BaseEstimator
from sklearn.preprocessing import LabelEncoder
from sklearn.utils import check_random_state
from joblib import Parallel, delayed
from utils import safediv, safelog, round_prob, sparse_block_matrix
class MultilayerPoissonLBM(BaseEstimator):
'''
Estimator for the multilayer Poisson Latent Block Model with
NumPy backend.
The inference procedure is adapted from the variational EM
algorithm introduced in [1].
Parameters
----------
H : int, default=3
Number of top clusters.
K : int, default=3
Number of bottom clusters.
epsilon : float, default=1e-7
Stopping criterion for the inference procedure.
The procedure keeps going as long as the relative variation of
the fuzzy log-likelihood after each iteration is greater than
epsilon.
max_iter : int, default=100
Maximum number of iterations in the inference procedure.
runs : int, default=20
Number of distinct runs of the inference procedure.
The best model across all runs is selected.
verbose : int, default=0
Level of verbosity.
If verbose == 0, no message is displayed.
If verbose >= 1, a message is displayed at the start and at
the end of each run of the inference procedure.
If verbose > 1, a message is displayed after each iteration of
the inference procedure.
random_state : int, default=None
Seed for the random number generator.
Attributes
----------
rnd : object
Random number generator.
I : int
Number of top nodes.
This attribute is set when fitting the model.
It is inferred from the data.
J : int
Number of bottom nodes.
This attribute is set when fitting the model.
It is inferred from the data.
L : int
Number of edge types.
This attribute is set when fitting the model.
It is inferred from the data.
top : LabelEncoder
Label encoder for the top nodes.
This attribute is set when fitting the model.
bottom : LabelEncoder
Label encoder for the bottom nodes.
This attribute is set when fitting the model.
types : LabelEncoder
Label encoder for the edge types.
This attribute is set when fitting the model.
G : list
List of sparse row matrices representing the layers of the
multiplex graph.
This attribute is set when fitting the model.
It is inferred from the data.
U : array of shape (self.I, self.H)
Array containing the fuzzy cluster assignments of the top
nodes.
This attribute is set when fitting the model.
V : array of shape (self.J, self.K)
Array containing the fuzzy cluster assignments of the bottom
nodes.
This attribute is set when fitting the model.
mu : array of shape (self.I,)
Array containing the marginal rates of the top nodes.
This attribute is set when fitting the model.
nu : array of shape (self.J,)
Array containing the marginal rates of the bottom nodes.
This attribute is set when fitting the model.
theta : array of shape (self.L, self.H, self.K)
Array containing the rate of each (edge type, top cluster,
bottom cluster) triple.
This attribute is set when fitting the model.
pi : array of shape (self.H,)
Array containing the probability of a top node being assigned
to each top cluster.
This attribute is set when fitting the model.
rho : array of shape (self.K,)
Array containing the probability of a bottom node being
assigned to each bottom cluster.
This attribute is set when fitting the model.
References
----------
[1] Govaert, Gerard and Nadif, Mohamed. Latent block model for
contingency table. In Commun. Stat. Theory Methods 39(3), 2010.
'''
def __init__(
self,
H=3,
K=3,
epsilon=1e-7,
max_iter=100,
runs=20,
verbose=0,
random_state=None
):
self.H = H
self.K = K
self.epsilon = epsilon
self.max_iter = max_iter
self.runs = runs
self.verbose = verbose
self.random_state = random_state
def fit(self, X, y=None):
'''
Fit the estimator.
Arguments
---------
X : array of shape (n_edges, 3)
Array of typed edges.
Each row contains three values: top node, bottom node, and
edge type.
These values can be strings or integers.
They are encoded using a LabelEncoder.
y : not used, included for consistency with the scikit-learn
API.
Returns
-------
self : object
Fitted estimator.
'''
self._make_graph(X)
self.rnd = check_random_state(self.random_state)
params = [self._fit_params() for i in range(self.runs)]
params.sort(key=lambda x: x[-1])
self.U, self.V, self.theta, self.mu, self.nu, _ = params[-1]
self.pi = self.U.mean(0)
self.rho = self.V.mean(0)
return self
def get_block_params(self):
'''
Returns top and bottom clusters inferred from the current soft
assignments, as well as the current rate matrices.
Returns
-------
U_dict : list
List of dictionaries corresponding to the top clusters.
The keys of each dictionary are the indices of the nodes
within it, and the corresponding values are their
probabilities of belonging to this cluster.
V_dict : list
List of dictionaries corresponding to the bottom clusters.
The keys of each dictionary are the indices of the nodes
within it, and the corresponding values are their
probabilities of belonging to this cluster.
theta : array of shape (self.L, self.H, self.K)
Array containing the rate of each (edge_type, top cluster,
bottom cluster) triple.
'''
U, V = round_prob(self.U), round_prob(self.V)
theta = self.theta
Up = [self.U[u, i] for i, u in enumerate(U)]
Vp = [self.V[v, j] for j, v in enumerate(V)]
U_dict = [dict(zip(u, up)) for u, up in zip(U, Up)]
V_dict = [dict(zip(v, vp)) for v, vp in zip(V, Vp)]
return U_dict, V_dict, theta
def get_results(self):
'''
Returns top and bottom clusters inferred from the current soft
assignments, as well as the current rate matrices, as
dictionaries containing the original names of the nodes and
edge types.
Returns
-------
top : list
List of dictionaries corresponding to the top clusters.
The keys of each dictionary are the names of the nodes
within it, and the corresponding values are their
probabilities of belonging to this cluster.
bottom : list
List of dictionaries corresponding to the bottom clusters.
The keys of each dictionary are the names of the nodes
within it, and the corresponding values are their
probabilities of belonging to this cluster.
thetas : dict
Dictionary containing the rate matrices for each edge type.
The keys are the names of the edge types, and the
corresponding values are the rate matrices in list-of-lists
format.
'''
U, V, T = self.get_block_params()
top = []
to_del = ([], [])
for i, u in enumerate(U):
keys = sorted(list(u.keys()))
if len(keys) > 0:
top.append(dict(zip(
self.top.inverse_transform(keys),
[u[k] for k in keys]
)))
else:
to_del[0].append(i)
bottom = []
for j, v in enumerate(V):
keys = sorted(list(v.keys()))
if len(keys) > 0:
bottom.append(dict(zip(
self.bottom.inverse_transform(keys),
[v[k] for k in keys]
)))
else:
to_del[1].append(j)
T = np.delete(
np.delete(
T, to_del[0], axis=1
),
to_del[1],
axis=2
)
thetas = dict([
(t, T[i, :, :].tolist())
for i, t in zip(
self.types.transform(self.types.classes_),
self.types.classes_
)
])
return top, bottom, thetas
def icl(self):
'''
Returns the logarithm of the integrated completed likelihood
(ICL) of the current model on the dataset stored in self.G.
See [1] for a definition of the ICL.
Returns
-------
icl : float
Integrated completed log-likelihood (the higher, the
better).
References
----------
[1] Biernacki, Christophe, et al. Assessing a mixture model for
clustering with the integrated completed likelihood.
In IEEE Trans. Pattern Anal. Mach. Intell. 22(7), 2000.
'''
res = 2*self._log_likelihood(fuzzy=False)
res -= (self.H - 1) * np.log(self.I)
res -= (self.K - 1) * np.log(self.J)
res -= (self.L * self.H * self.K) * np.log(
self.L * self.I * self.J
)
return .5*res
def _build_graph(self, X):
'''
Builds a sparse matrix-based representation of the input data
and stores it into self.G.
Arguments
---------
X : array of shape (n_edges, 3)
Array of typed edges.
Each row contains three values: top node, bottom node, and
edge type.
These values can be strings or integers.
'''
self.G = []
for l in range(self.L):
t = self.types.inverse_transform([l])[0]
Xt = X[X[:, 2] == t]
top = self.top.transform(Xt[:, 0])
bottom = self.bottom.transform(Xt[:, 1])
g = csr_matrix(
(
np.ones(Xt.shape[0]),
(top, bottom)
),
shape=(self.I, self.J)
)
self.G.append(g)
def _copy_params(self):
'''
Returns a copy of the current parameters (soft cluster
assignments, rate matrices, and marginal rates of the nodes).
Returns
-------
U : array of shape (self.I, self.H)
Copy of self.U.
V : array of shape (self.J, self.K)
Copy of self.V.
theta : array of shape (self.L, self.H, self.K)
Copy of self.theta.
mu : array of shape (self.I,)
Copy of self.mu.
nu : array of shape (self.J,)
Copy of self.nu.
'''
res = (
np.array(self.U),
np.array(self.V),
np.array(self.theta),
np.array(self.mu),
np.array(self.nu)
)
return res
def _estimate_clusters(self, top):
'''
E-step of the inference procedure.
Estimates the soft cluster assignments of the top or bottom
nodes given the current parameters and the data stored in
self.G.
The result is returned as an array of shape
(n_nodes, n_clusters).
Arguments
---------
top : bool
If true, soft cluster assignments are evaluated for the
top nodes.
Otherwise, the assignments of the bottom nodes are
evaluated.
Returns
-------
assignments : array of shape (n_nodes, n_clusters)
Soft cluster assignments of the top nodes if top is true,
and of the bottom nodes otherwise.
'''
if top:
Gp = np.stack([g.dot(self.V) for g in self.G])
X1 = (
Gp[:, :, np.newaxis, :] * safelog(
self.theta[:, np.newaxis, :, :]
)
).sum((0, 3))
else:
Gp = np.stack([g.T.dot(self.U).T for g in self.G])
X1 = (
Gp[:, :, :, np.newaxis] * safelog(
self.theta[:, :, np.newaxis, :]
)
).sum((0, 1))
theta = self.theta
if not top:
theta = theta.transpose(0, 2, 1)
Y = self.V if top else self.U
m = self.mu if top else self.nu
n = self.nu if top else self.mu
X2 = -m[:, np.newaxis] * (
np.matmul(
theta,
np.matmul(
Y.T,
n[:, np.newaxis]
)[np.newaxis, :, :]
)[:, np.newaxis, :, 0]
).sum(0)
p = self.pi if top else self.rho
X = X1 + X2 + safelog(p, backend='numpy')
X = np.exp(X - np.amax(X, 1)[:, np.newaxis])
return X/X.sum(1)[:, np.newaxis]
def _estimate_theta(self):
'''
M-step of the inference procedure.
Estimates the rate matrices given the soft cluster assignments
and the data stored in self.G.
The result is returned as an array of shape
(n_layers, n_top_clusters, n_bottom_clusters).
Returns
-------
theta : array of shape (self.L, self.H, self.K)
Stacked rate matrices (one per edge type).
'''
M = np.stack([self.U.T.dot(g.dot(self.V)) for g in self.G])
P = np.tile(
np.matmul(
self.mu.dot(self.U)[:, np.newaxis],
self.nu.dot(self.V)[np.newaxis, :]
),
(self.L, 1, 1)
)
return safediv(M, P)
def _fit_params(self):
'''
Runs the inference procedure on the data stored in self.G and
returns the obtained parameters.
Returns
-------
U : array of shape (self.I, self.H)
Inferred soft cluster assignments of the top nodes.
V : array of shape (self.J, self.K)
Inferred soft cluster assignments of the bottom nodes.
theta : array of shape (self.L, self.H, self.K)
Inferred rate matrices.
mu : array of shape (self.I,)
Inferred marginal rates of the top nodes.
nu : array of shape (self.J,)
Inferred marginal rates of the bottom nodes.
score : float
Complete data log-likelihood of the inferred parameters.
'''
start_time = time.time()
self._initialize()
old_score = self._log_likelihood()
diff = 10
n_iter = 0
if self.verbose > 0:
print('[*] Starting inference (H=%d, K=%d)' % (self.H, self.K))
while diff > self.epsilon and n_iter < self.max_iter:
self.U = self._estimate_clusters(True)
self.pi = self.U.mean(0)
self.V = self._estimate_clusters(False)
self.rho = self.V.mean(0)
self.theta = self._estimate_theta()
score = self._log_likelihood()
diff = np.abs(1-safediv(score, old_score))
old_score = score
n_iter += 1
if self.verbose > 1:
print(
'\tIteration %d; Log-likelihood: %f' % (n_iter, score)
)
end_time = time.time()
if self.verbose > 0:
diff = end_time - start_time
minutes = int(diff)//60
seconds = diff % 60
print((
'[*] Reached convergence after %d iterations '
'(%d min %d sec); '
'Log-likelihood: %f\n'
) % (
n_iter, minutes, seconds, score
)
)
score = self._log_likelihood(fuzzy=False)
res = self._copy_params()
return (*res, score)
def _initialize(self):
'''
Initializes the parameters of the model.
'''
U = self.rnd.uniform(size=(self.I, self.H))
self.U = U/U.sum(1)[:, np.newaxis]
V = self.rnd.uniform(size=(self.J, self.K))
self.V = V/V.sum(1)[:, np.newaxis]
tot = np.sqrt(sum(g.sum() for g in self.G))
self.mu = sum(
np.array(g.sum(1))[:, 0]
for g in self.G
)/tot
self.nu = sum(
np.array(g.sum(0))[0, :]
for g in self.G
)/tot
self.theta = self.rnd.uniform(size=(self.L, self.H, self.K))
self.pi = self.rnd.uniform(size=(self.H,))
self.pi /= self.pi.sum()
self.rho = self.rnd.uniform(size=(self.K,))
self.rho /= self.rho.sum()
def _log_likelihood(self, fuzzy=True):
'''
Computes the (exact or fuzzy) complete data log-likelihood of
the current model for the dataset stored in self.G.
Arguments
---------
fuzzy : bool
If true, the fuzzy criterion introduced in [1] is computed.
Otherwise, the exact complete data log-likelihood (with
hard cluster assignments) is returned.
Returns
-------
score : float
Exact or fuzzy log-likelihood of the current model.
References
----------
[1] Govaert, Gerard and Nadif, Mohamed. Latent block model for
contingency table. In Commun. Stat. Theory Methods 39(3), 2010.
'''
if not fuzzy:
U = sparse_block_matrix(round_prob(self.U)).toarray()
V = sparse_block_matrix(round_prob(self.V)).toarray()
res = 0
else:
U, V = self.U, self.V
res = entropy(U, axis=1).sum() + entropy(V, axis=1).sum()
res += U.dot(safelog(self.pi)).sum()
res += V.dot(safelog(self.rho)).sum()
res += sum(
(
U.T.dot(
g.dot(V)) * safelog(
self.theta[i, :, :]
)
- U.T.dot(self.mu)[:, np.newaxis].dot(
V.T.dot(self.nu)[np.newaxis, :]
) * self.theta[i, :, :]
).sum()
for i, g in enumerate(self.G)
)
if not fuzzy:
res += sum(
g.T.dot(safelog(self.mu)).sum()
+ g.dot(safelog(self.nu)).sum()
for g in self.G
)
return res
def _make_graph(self, X):
'''
Builds the label encoders for top nodes, bottom nodes and edge
types, then builds the multiplex graph representing the input
dataset and stores it into self.G.
Arguments
---------
X : array of shape (n_edges, 3)
Array of typed edges.
Each row contains three values: top node, bottom node, and
edge type.
These values can be strings or integers.
'''
encoders = [LabelEncoder() for i in range(3)]
for i, e in enumerate(encoders):
e.fit(X[:, i])
self.top, self.bottom, self.types = encoders
self.I = len(self.top.classes_)
self.J = len(self.bottom.classes_)
self.L = len(self.types.classes_)
self._build_graph(X)
class TorchMultilayerPoissonLBM(MultilayerPoissonLBM):
'''
Estimator for the multilayer Poisson Latent Block Model with
PyTorch backend.
The inference procedure is adapted from the variational EM
algorithm introduced in [1].
Parameters
----------
H : int, default=3
Number of top clusters.
K : int, default=3
Number of bottom clusters.
epsilon : float, default=1e-7
Stopping criterion for the inference procedure.
The procedure keeps going as long as the relative variation of
the fuzzy log-likelihood after each iteration is greater than
epsilon.
max_iter : int, default=100
Maximum number of iterations in the inference procedure.
runs : int, default=20
Number of distinct runs of the inference procedure.
The best model across all runs is selected.
verbose : int, default=0
Level of verbosity.
If verbose == 0, no message is displayed.
If verbose >= 1, a message is displayed at the start and at
the end of each run of the inference procedure.
If verbose > 1, a message is displayed after each iteration of
the inference procedure.
device : str, default='cuda'
Identifier of the device used by PyTorch.
random_state : int, default=None
Seed for the random number generator.
Attributes
----------
rnd : object
Random number generator.
I : int
Number of top nodes.
This attribute is set when fitting the model.
It is inferred from the data.
J : int
Number of bottom nodes.
This attribute is set when fitting the model.
It is inferred from the data.
L : int
Number of edge types.
This attribute is set when fitting the model.
It is inferred from the data.
top : LabelEncoder
Label encoder for the top nodes.
This attribute is set when fitting the model.
bottom : LabelEncoder
Label encoder for the bottom nodes.
This attribute is set when fitting the model.
types : LabelEncoder
Label encoder for the edge types.
This attribute is set when fitting the model.
G : list
List of sparse tensors representing the layers of the
multiplex graph.
This attribute is set when fitting the model.
It is inferred from the data.
U : tensor of shape (self.I, self.H)
Tensor containing the fuzzy cluster assignments of the top
nodes.
This attribute is set when fitting the model.
V : tensor of shape (self.J, self.K)
Tensor containing the fuzzy cluster assignments of the bottom
nodes.
This attribute is set when fitting the model.
mu : tensor of shape (self.I,)
Tensor containing the marginal rates of the top nodes.
This attribute is set when fitting the model.
nu : tensor of shape (self.J,)
Tensor containing the marginal rates of the bottom nodes.
This attribute is set when fitting the model.
theta : tensor of shape (self.L, self.H, self.K)
Tensor containing the rate of each (edge type, top cluster,
bottom cluster) triple.
This attribute is set when fitting the model.
pi : tensor of shape (self.H,)
Tensor containing the probability of a top node being assigned
to each top cluster.
This attribute is set when fitting the model.
rho : tensor of shape (self.K,)
Tensor containing the probability of a bottom node being
assigned to each bottom cluster.
This attribute is set when fitting the model.
References
----------
[1] Govaert, Gerard and Nadif, Mohamed. Latent block model for
contingency table. In Commun. Stat. Theory Methods 39(3), 2010.
'''
def __init__(
self,
H=3,
K=3,
epsilon=1e-7,
max_iter=100,
runs=20,
verbose=0,
device='cuda',
random_state=None
):
super(TorchMultilayerPoissonLBM, self).__init__(
H=H,
K=K,
epsilon=epsilon,
max_iter=max_iter,
runs=runs,
verbose=verbose,
random_state=random_state
)
self.device = torch.device(device)
def get_block_params(self):
'''
Returns top and bottom clusters inferred from the current soft
assignments, as well as the current rate matrices.
Returns
-------
U_dict : list
List of dictionaries corresponding to the top clusters.
The keys of each dictionary are the indices of the nodes
within it, and the corresponding values are their
probabilities of belonging to this cluster.
V_dict : list
List of dictionaries corresponding to the bottom clusters.
The keys of each dictionary are the indices of the nodes
within it, and the corresponding values are their
probabilities of belonging to this cluster.
theta : array of shape (self.L, self.H, self.K)
Array containing the rate of each (edge_type, top cluster,
bottom cluster) triple.
'''
U = round_prob(self.U.cpu().numpy())
V = round_prob(self.V.cpu().numpy())
theta = self.theta.cpu().numpy()
Up = [
self.U[u, i].cpu().numpy().astype(float)
for i, u in enumerate(U)
]
Vp = [
self.V[v, j].cpu().numpy().astype(float)
for j, v in enumerate(V)
]
U_dict = [dict(zip(u, up)) for u, up in zip(U, Up)]
V_dict = [dict(zip(v, vp)) for v, vp in zip(V, Vp)]
return U_dict, V_dict, theta
def _build_graph(self, X):
'''
Builds a sparse tensor-based representation of the input data
and stores it into self.G.
Arguments
---------
X : array of shape (n_edges, 3)
Array of typed edges.
Each row contains three values: top node, bottom node, and
edge type.
These values can be strings or integers.
'''
self.G = []
for l in range(self.L):
t = self.types.inverse_transform([l])[0]
Xt = X[X[:, 2] == t]
top = self.top.transform(Xt[:, 0])
bottom = self.bottom.transform(Xt[:, 1])
index = torch.from_numpy(
np.stack([top, bottom], axis=1)
).T.to(self.device)
values = torch.ones(Xt.shape[0]).to(self.device)
g = (index, values)
self.G.append(g)
def _copy_params(self):
'''
Returns a copy of the current parameters (soft cluster
assignments, rate matrices, and marginal rates of the nodes).
Returns
-------
U : tensor of shape (self.I, self.H)
Copy of self.U.
V : tensor of shape (self.J, self.K)
Copy of self.V.
theta : tensor of shape (self.L, self.H, self.K)
Copy of self.theta.
mu : tensor of shape (self.I,)
Copy of self.mu.
nu : tensor of shape (self.J,)
Copy of self.nu.
'''
res = (
self.U.clone(),
self.V.clone(),
self.theta.clone(),
self.mu.clone(),
self.nu.clone()
)
return res
def _estimate_clusters(self, top):
'''
E-step of the inference procedure.
Estimates the soft cluster assignments of the top or bottom
nodes given the current parameters and the data stored in
self.G.
The result is returned as a tensor of shape
(n_nodes, n_clusters).
Arguments
---------
top : bool
If true, soft cluster assignments are evaluated for the
top nodes.
Otherwise, the assignments of the bottom nodes are
evaluated.
Returns
-------
assignments : tensor of shape (n_nodes, n_clusters)
Soft cluster assignments of the top nodes if top is true,
and of the bottom nodes otherwise.
'''
if top:
X1 = sum(
(
spmm(
g[0],
g[1],
self.I,
self.J,
self.V
).unsqueeze(1)
* safelog(
self.theta[l, :, :],
backend='torch'
).unsqueeze(0)
).sum(2)
for l, g in enumerate(self.G)
)
else:
X1 = sum(
(
spmm(
*transpose(g[0], g[1], self.I, self.J),
self.J,
self.I,
self.U
).T.unsqueeze(2)
* safelog(
self.theta[l, :, :],
backend='torch'
).unsqueeze(1)
).sum(0)
for l, g in enumerate(self.G)
)
theta = self.theta
if not top:
theta = theta.transpose(2, 1)
Y = self.V if top else self.U
m = self.mu if top else self.nu
n = self.nu if top else self.mu
X2 = -m.unsqueeze(1) * (
torch.matmul(
theta,
torch.matmul(
Y.T,
n.unsqueeze(1)
).unsqueeze(0)
).unsqueeze(1).squeeze(3)
).sum(0)
p = self.pi if top else self.rho
X = X1 + X2 + safelog(p, backend='torch')
X = torch.exp(X - torch.amax(X, 1).unsqueeze(1))
return X/X.sum(1).unsqueeze(1)
def _estimate_theta(self):
'''
M-step of the inference procedure.
Estimates the rate matrices given the soft cluster assignments
and the data stored in self.G.
The result is returned as a tensor of shape
(n_layers, n_top_clusters, n_bottom_clusters).
Returns
-------
theta : tensor of shape (self.L, self.H, self.K)
Stacked rate matrices (one per edge type).
'''
M = torch.stack([
self.U.T.matmul(
spmm(g[0], g[1], self.I, self.J, self.V)
)
for g in self.G
])
P = torch.matmul(
torch.matmul(self.mu, self.U).unsqueeze(1),
torch.matmul(self.nu, self.V).unsqueeze(0)
).repeat((self.L, 1, 1))
return safediv(M, P)
def _initialize(self):
'''
Initializes the parameters of the model.
'''
U = self.rnd.uniform(size=(self.I, self.H))
self.U = U/U.sum(1)[:, np.newaxis]
V = self.rnd.uniform(size=(self.J, self.K))
self.V = V/V.sum(1)[:, np.newaxis]
tot = torch.sqrt(sum(g[1].sum() for g in self.G))
self.mu = sum(
spmm(
g[0], g[1], self.I, self.J,
g[0].new_ones(self.J).unsqueeze(1)
).squeeze(1)
for g in self.G
)/tot
self.nu = sum(
spmm(
*transpose(g[0], g[1], self.I, self.J),
self.J, self.I,
g[0].new_ones(self.I).unsqueeze(1)
).squeeze(1)
for g in self.G
)/tot
self.theta = self.rnd.uniform(size=(self.L, self.H, self.K))
self.pi = self.rnd.uniform(size=(self.H,))
self.pi /= self.pi.sum()
self.rho = self.rnd.uniform(size=(self.K,))
self.rho /= self.rho.sum()
def make_params(params):
res = [
torch.from_numpy(
p.astype(np.float32)
).to(self.device)
for p in params
]
return res
self.U, self.V, self.theta, self.pi, self.rho = make_params([
self.U, self.V, self.theta,
self.pi, self.rho
])
def _log_likelihood(self, fuzzy=True):
'''
Computes the (exact or fuzzy) complete data log-likelihood of
the current model for the dataset stored in self.G.
Arguments
---------
fuzzy : bool
If true, the fuzzy criterion introduced in [1] is computed.
Otherwise, the exact complete data log-likelihood (with
hard cluster assignments) is returned.
Returns
-------
score : float
Exact or fuzzy log-likelihood of the current model.
References
----------
[1] Govaert, Gerard and Nadif, Mohamed. Latent block model for
contingency table. In Commun. Stat. Theory Methods 39(3), 2010.
'''
if not fuzzy:
U = torch.from_numpy(
sparse_block_matrix(
round_prob(self.U.cpu())
).toarray().astype(np.float32)
).to(self.device)
V = torch.from_numpy(
sparse_block_matrix(
round_prob(self.V.cpu())
).toarray().astype(np.float32)
).to(self.device)
res = 0
else:
U, V = self.U, self.V
res = entropy(U.cpu().numpy(), axis=1).sum()
res += entropy(V.cpu().numpy(), axis=1).sum()
Gp = [
spmm(g[0], g[1], self.I, self.J, V)
for g in self.G
]
res += sum(
(
U.T.matmul(g) * safelog(
self.theta[i, :, :],
backend='torch'
)
- U.T.matmul(self.mu).unsqueeze(1).matmul(
V.T.matmul(self.nu).unsqueeze(0)
) * self.theta[i, :, :]
).sum()
for i, g in enumerate(Gp)
)
if not fuzzy:
for g in self.G:
res += spmm(
g[0], g[1], self.I, self.J,
safelog(
self.nu,
backend='torch'
).unsqueeze(1)
).sum()
index, value = transpose(g[0], g[1], self.I, self.J)
res += spmm(
index, value, self.J, self.I,
safelog(
self.mu,
backend='torch'
).unsqueeze(1)
).sum()
return res.data.item()
def fit_mlplbm(
X,
H=(3, 4, 5, 6),
K=(3, 4, 5, 6),
epsilon=1e-7,
max_iter=100,
runs=20,
n_jobs=1,
verbose=0,
backend='numpy',
device=['cuda'],
random_state=None
):
def fit_model(params, device):
if backend == 'numpy':
return [
MultilayerPoissonLBM(
h,
k,
epsilon=epsilon,
max_iter=max_iter,
runs=runs,
verbose=verbose,
random_state=random_state
).fit(X)
for h, k in params
]
else:
return [
TorchMultilayerPoissonLBM(
h,
k,
epsilon=epsilon,
max_iter=max_iter,
runs=runs,
verbose=verbose,
device=device,
random_state=random_state
).fit(X)
for h, k in params
]
params = [(h, k) for h in H for k in K]
chunks = [[] for i in range(n_jobs)]
for i, p in enumerate(params):
chunks[i%n_jobs].append(p)
res = Parallel(n_jobs=n_jobs)(
delayed(fit_model)(chunks[i], device[i%len(device)])
for i in range(n_jobs)
)
models = [m for r in res for m in r]
crit = [m.icl() for m in models]
best = [m for i, m in enumerate(models) if crit[i] == max(crit)]
best.sort(key=lambda m: m.H + m.K)
return best[0]
| 28,746 | 24.040941 | 67 | py |
CentSmoothieCode | CentSmoothieCode-master/models/weightCentSmooth.py | import torch
import torch.nn.functional as F
import numpy as np
import params
from torch_scatter.scatter import scatter_add
class WHGNN(torch.nn.Module):
def __init__(self, featureSize, embeddingSize, nSe, nD, nLayer=params.N_LAYER, device=torch.device('cpu')):
super(WHGNN, self).__init__()
self.nSe = nSe
self.nD = nD
self.nV = nSe + nD
self.embeddingSize = embeddingSize
self.device = device
self.feature2EmbedLayer1 = torch.nn.Linear(featureSize, embeddingSize)
self.feature2EmbedLayer2 = torch.nn.Linear(embeddingSize, embeddingSize)
self.embeddingSe = torch.nn.Embedding(nSe, embeddingSize)
self.embeddingSe.weight.data.uniform_(0.001, 0.3)
self.layerWeightList = []
self.dimWeightList = []
self.nLayer = nLayer
self.dim1s = [i for i in range(self.nD)]
self.dim2s = [i for i in range(self.nD)]
self.dim3s = [i for i in range(self.nSe)]
for i in range(nLayer):
layer = torch.nn.Linear(embeddingSize, embeddingSize, bias=True).to(self.device)
self.register_parameter("layerWeight" + "%s" % i, layer.weight)
self.register_parameter("layerWBias" + "%s" % i, layer.bias)
self.layerWeightList.append(layer)
for i in range(nLayer):
dimWeight = torch.nn.Embedding(nSe, embeddingSize).to(self.device)
dimWeight.share_memory()
# dimWeight.weight.data.uniform_(0.001, 0.3)
dimWeight.weight.data.fill_(1)
if not params.LEARN_WEIGHT_IN:
dimWeight.weight.requires_grad = False
dimWeight.weight.data.fill_(1)
self.dimWeightList.append(dimWeight)
self.register_parameter("dimWeight" + "%s" % i, dimWeight.weight)
# Last dimWeight:
lastDimWeight = torch.nn.Embedding(nSe, embeddingSize).to(self.device)
lastDimWeight.share_memory()
lastDimWeight.weight.data.uniform_(0.001, 1)
if not params.LEARN_WEIGHT_LAST:
lastDimWeight.weight.requires_grad = False
lastDimWeight.weight.data.fill_(1)
self.lastDimWeight = lastDimWeight
self.dOnes = torch.ones(self.nV).to(self.device)
self.diagI = torch.diag(torch.ones(self.nV)).to(self.device)
seIndices = [i for i in range(self.nSe)]
self.seIndices = torch.from_numpy(np.asarray(seIndices)).long().to(self.device)
def getWLoss(self, target, pred, w=params.L_W):
s = target.shape
arx = torch.full(s, w).to(self.device)
arx[target == 1] = 1
e = target - pred
e = e ** 2
e = arx * e
return torch.mean(e)
def sampleDims(self, nsample=-1, isFull=False, toTuple=True):
tp = None
if isFull:
d1, d2, dse = torch.from_numpy(np.arange(0, self.nD)).long().to(self.device), \
torch.from_numpy(np.arange(0, self.nD)).long().to(self.device), \
torch.from_numpy(np.arange(0, self.nSe)).long().to(self.device)
else:
d1, d2, dse = torch.from_numpy(np.random.choice(self.dim1s, nsample, replace=False)).long().to(self.device), \
torch.from_numpy(np.random.choice(self.dim2s, nsample, replace=False)).long().to(self.device), \
torch.from_numpy(np.random.choice(self.dim3s, nsample, replace=False)).long().to(self.device)
if toTuple:
td2 = d2.expand(nsample, -1).t().reshape(-1).expand(nsample, -1).reshape(-1)
tdse = dse.expand(nsample, -1).reshape(-1).expand(nsample, -1).reshape(-1) + self.nD
td1 = d1.expand(nsample * nsample, nsample).t().reshape(-1)
tp = torch.vstack((td1, td2, tdse)).t().to(self.device)
return d1, d2, dse, tp
def projectNonNegW(self):
for dimWeight in self.dimWeightList:
dimWeight.weight.data[dimWeight.weight.data < 0] = 0
# dimWeight.weight.data[dimWeight.weight.data > 1] = 1
self.lastDimWeight.weight.data[self.lastDimWeight.weight.data < 0] = 0
def construct1L(self, iDim, pos, wids, weights, iLayer=0, export=False):
if iLayer == -1:
wi = self.lastDimWeight
else:
wi = self.dimWeightList[iLayer]
ws = wi(wids)
ws = ws[:, iDim]
ws = ws * weights
nSize = self.nV * self.nV
x = scatter_add(ws, pos, dim_size=nSize)
L2 = x.reshape(self.nV, self.nV)
L2 = L2 + L2.t()
diag = torch.diag(torch.diag(L2))
L2 = L2 - diag / 2
L = L2
assert torch.sum(L) < 10
return L
def constructCentL(self, pos, wids, weights, iLayer=0, export=False):
if iLayer == -1:
wi = self.lastDimWeight
else:
wi = self.dimWeightList[iLayer]
nDim = wi.weight.shape[1]
assert nDim == self.embeddingSize
sSize = self.nV * self.nV
aSize = sSize * nDim
xpos = pos.repeat(nDim)
xweights = weights.repeat(nDim)
sz = pos.shape[0]
ws = wi(wids).t().reshape(-1)
ws = ws * xweights
for iDim in range(nDim):
xpos[iDim * sz: (iDim + 1) * sz] += iDim * sSize
x = scatter_add(ws, xpos, dim_size=aSize)
LL = x.reshape((nDim, self.nV, self.nV))
for iDim in range(nDim):
Li = LL[iDim]
L2 = Li + Li.t()
diag = torch.diag(torch.diag(L2)).to(self.device)
L2 = L2 - diag / 2
assert torch.sum(L2) < 10
LL[iDim] = L2
return LL
# def constructCentL(self, pos, cors, wids, wi, nV):
# # Parameters:
# # nV: Number of nodes
# # wi: Embedding for side effect weights
# # pos: Serialized positions of each side effect
# # weight to the corresponding position (i,j)
# # in the Laplacian matrix, computed by:
# # i * nV + j
# # cors: Coefficients corresponding to pos
# # Return:
# # Central-smoothing hypergraph Laplacian matrices for
# # K dimensions.
#
# K = wi.weight.shape[1]
# sSize = nV * nV
# aSize = sSize * K
# xpos = pos.repeat(K)
# xcors = cors.repeat(K)
# sz = pos.shape[0]
# ws = wi(wids).t().reshape(-1)
# ws = ws * xcors
# for iDim in range(K):
# xpos[iDim * sz: (iDim + 1) * sz] += iDim * sSize
# x = scatter_add(ws, xpos, dim_size=aSize)
# LL = x.reshape((K, nV, nV))
# for iDim in range(K):
# Li = LL[iDim]
# L2 = Li + Li.t()
# diag = torch.diag(torch.diag(L2)).to(self.device)
# L2 = L2 - diag / 2
# LL[iDim] = L2
# return LL
def normDegL(self, L):
d = torch.diag(L)
diag = torch.diag(d)
A = diag - L
A2 = A + self.diagI
D = torch.sum(A2, dim=1)
D = torch.pow(torch.sqrt(D), -1)
DM12 = torch.diag(D)
normA = torch.matmul(torch.matmul(DM12, A2), DM12)
assert torch.min(d) >= 0
assert torch.min(D) > 0
return normA, d
def normDegL2(self, L):
d = torch.diag(L)
diag = torch.diag(d)
A = diag - L
A2 = A + self.diagI
normA = A2 / torch.max(A2)
return normA, self.dOnes
def forward1(self, drugFeatures, dd):
drugF = F.relu(self.feature2EmbedLayer1(drugFeatures))
drugF = F.relu(self.feature2EmbedLayer2(drugF))
xSe = self.embeddingSe(self.seIndices)
x = torch.cat((drugF, xSe), 0)
pos, wids, weights = dd
self.finalD = []
if not params.LEARN_WEIGHT_IN:
Li = self.construct1L(0, pos, wids, weights, 0, export=True)
if params.ON_REAL:
A, D = self.normDegL(Li)
else:
A, _ = self.normDegL2(Li)
for iLayer, layerWeight in enumerate(self.layerWeightList):
if params.LEARN_WEIGHT_IN:
lList = self.constructCentL(pos, wids, weights, iLayer)
AA = torch.empty((self.embeddingSize, self.nV, self.nV)).to(self.device)
for iDim in range(self.embeddingSize):
Li = lList[iDim].squeeze()
if params.ON_REAL:
Ai, _ = self.normDegL(Li)
else:
Ai, _ = self.normDegL2(Li)
AA[iDim] = Ai
x = x.t().unsqueeze(-1)
x2 = torch.bmm(AA, x)
x2 = x2.squeeze().t()
if params.LAYER_WEIGHT:
x2 = layerWeight(x2)
x = F.relu(x2)
else:
x = torch.matmul(A, x)
if params.LAYER_WEIGHT:
x = layerWeight(x)
x = F.relu(x)
# Last layer:
if params.ON_REAL:
lList = self.constructCentL(pos, wids, weights, -1)
for iDim in range(self.embeddingSize):
Li = lList[iDim].squeeze()
Ai, Di = self.normDegL(Li)
# print("Last A D: ", Ai[0, :10], Di[:10])
Di[Di == 0] = 1
rsqrtD = torch.pow(torch.sqrt(Di), -1)
self.finalD.append(rsqrtD)
else:
rsqrtD = self.dOnes
for iDim in range(self.embeddingSize):
self.finalD.append(rsqrtD)
self.finalX = x
return self.finalX
def forward2(self, x, tpl):
xd1 = x[tpl[:, 0]]
xd2 = x[tpl[:, 1]]
xse = x[tpl[:, 2]]
v = 0
seIds = tpl[:, 2] - self.nD
w = self.lastDimWeight(seIds)
for iDim in range(self.embeddingSize):
xd1i = xd1[:, iDim]
xd2i = xd2[:, iDim]
xsei = xse[:, iDim]
wei = w[:, iDim]
rsqrtdeg = self.finalD[iDim]
dd1 = rsqrtdeg[tpl[:, 0]]
dd2 = rsqrtdeg[tpl[:, 1]]
dd3 = rsqrtdeg[tpl[:, 2]]
xd1i = xd1i * dd1
xd2i = xd2i * dd2
xsei = xsei * dd3
vi = (xd1i + xd2i) / 2 - xsei
vi = vi * wei
vi = torch.squeeze(vi)
vi = torch.mul(vi, vi)
v += vi
smt = v
out = smt + 1 + 1e-2
out2 = 1 / out
return out2
| 10,465 | 33.541254 | 122 | py |
CentSmoothieCode | CentSmoothieCode-master/models/trainWeightCentL.py | from models.weightCentSmooth import WHGNN
import torch
import numpy as np
import inspect
import params
from sklearn.metrics import roc_auc_score, average_precision_score, f1_score
from utils import utils
import time
def getMSE(a1, a2):
v = a1 - a2
v = np.multiply(v, v)
return np.sqrt(np.sum(v) / (v.shape[0] * v.shape[0]))
class WrapperWeightCentSmooth:
def __init__(self, device=torch.device('cpu')):
self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
self.name = "WGCN"
self.isFitAndPredict = True
def setLogger(self, logger):
self.logger = logger
self.logger.infoAll(inspect.getsource(WHGNN))
def getLoss(self, out1, out2, reg=None):
# print(torch.min(out1), torch.max(out1), torch.min(out2), torch.max(out2))
e1 = - torch.sum(torch.log(out1)) - torch.sum(torch.log(1 - out2))
if reg is not None:
if params.R_TYPE == "L1":
e1 += params.LAMBDA_R * torch.sum(torch.abs(reg))
else: # L2:
e1 += params.LAMBDA_R * torch.sum(torch.mul(reg, reg))
return e1
def convertDictNp2LongTensor(self, d):
d2 = dict()
for k, v in d.items():
v = torch.from_numpy(v).long()
d2[k] = v
return d2
def list2Pair(self, l):
dCount = dict()
for v in l:
utils.add_dict_counter(dCount, v)
ks = []
vs = []
for k, v in dCount.items():
ks.append(k)
vs.append(v)
ks = np.asarray(ks)
vs = np.asarray(vs)
return ks, vs
def convertDictNp2PairLongTensor(self, d):
d2 = dict()
for k, v in d.items():
ks, vs = self.list2Pair(v)
ks = torch.from_numpy(ks).long().to(self.device)
vs = torch.from_numpy(vs).float().to(self.device)
d2[k] = (ks, vs)
return d2
def convertAllDict2LongList(self, dd, dimSize):
pos = []
wids = []
weights = []
for ix, d in enumerate(dd):
if ix == 0 or ix == 1:
w = 0.25
elif ix == 2:
w = -0.5
else:
w = 1
for k, v in d.items():
i, j = k
assert i <= j
ps = i * dimSize + j
ks, vs = self.list2Pair(v)
for jj in range(ks.shape[0]):
wid = ks[jj]
count = vs[jj]
wids.append(wid)
weights.append(count * w)
pos.append(ps)
pos = torch.from_numpy(np.asarray(pos)).long().to(self.device)
wids = torch.from_numpy(np.asarray(wids)).long().to(self.device)
weights = torch.from_numpy(np.asarray(weights)).float().to(self.device)
return pos, wids, weights
def selectSubIndices(self, secs, tpls):
secs = secs[::-1]
sz = len(secs)
indices = [[] for _ in range(sz)]
for ii, tpl in enumerate(tpls):
_, _, adrIdOf = tpl
i = sz
for i, sec in enumerate(secs):
if adrIdOf in sec:
break
for j in range(i, sz):
indices[j].append(ii)
res = []
for indice in indices:
res.append(np.asarray(indice))
return res
def loadNegIds(self, ses, secs, tpls, segId=0):
secs = secs[::-1]
sz = len(secs)
indices = [[] for _ in range(sz)]
dSeId2Tpls = dict()
dSeId2Indices = dict()
ses2 = set(ses)
for seOfId in ses:
dSeId2Tpls[seOfId] = []
dSeId2Indices[seOfId] = []
for ii, tpl in enumerate(tpls):
_, _, adrIdOf = tpl
i = sz
for i, sec in enumerate(secs):
if adrIdOf in sec:
break
for j in range(i, sz):
indices[j].append(ii)
selectedIndices1 = indices[segId]
for idx in selectedIndices1:
tpt = tpls[idx]
_, _, adrIdOf = tpt
if adrIdOf in ses2:
dSeId2Tpls[adrIdOf].append(tpt)
dSeId2Indices[adrIdOf].append(idx)
for k, v in dSeId2Tpls.items():
dSeId2Tpls[k] = np.asarray(v)
return dSeId2Tpls, dSeId2Indices
def visual2(self, trainTpl, seId, nD, finalX, method, selectedPairs=[], iFold=5, dId2SeName={}, dId2DrugName={}):
finalX = finalX / np.max(np.fabs(finalX))
print("MAX V", np.max(finalX))
print(selectedPairs)
drugIDSet = set()
seIdOf = seId + nD
drugPairSet = []
for tpl in trainTpl:
d1, d2, s = tpl
if s == seIdOf:
drugPairSet.append([d1, d2])
drugIDSet.add(d1)
drugIDSet.add(d2)
mxPair = len(drugPairSet)
drugIDList = list(drugIDSet)
from postprocessing.visualization import plotData2
title = r'$\mathrm{CentSmoothie}$'
plotData2(finalX, "%s_%s" % (method, iFold), title, offset=nD, sid=seIdOf, dPairs=drugPairSet[:mxPair],
selectVDrugPair=selectedPairs, drugIDList=drugIDList, dSe2Name=dId2SeName,
dDrug2Name=dId2DrugName)
def exportTopNeg(self, dSeId2Tpls, dSeId2Indices, NegRes, nD, dADR2Name, dDrug2Name, outFile):
seOfIds = sorted(dSeId2Indices.keys())
sorteddSeId2Tpls = dict()
sortedSeId2Scores = dict()
for seOfId in seOfIds:
indices = dSeId2Indices[seOfId]
tpls = dSeId2Tpls[seOfId]
res = NegRes[indices]
assert len(res) == len(tpls)
sortedIndiceScores = np.argsort(res)[::-1]
assert res[sortedIndiceScores[0]] >= res[sortedIndiceScores[1]]
# print(res[sortedIndiceScores[0]])
rr = []
orr = dSeId2Tpls[seOfId]
rscore = []
for idx in sortedIndiceScores:
d1, d2, _ = orr[idx]
rr.append((d1, d2))
rscore.append(res[idx])
sorteddSeId2Tpls[seOfId - nD] = rr
sortedSeId2Scores[seOfId - nD] = rscore
fout = open(outFile, "w")
for k, v in sorteddSeId2Tpls.items():
adrName = dADR2Name[k]
drugPairs = v
rscore = sortedSeId2Scores[k]
fout.write("%s\n" % adrName)
for ii, pair in enumerate(drugPairs):
d1, d2 = pair
fout.write("\t%s, %s, %s\n" % (dDrug2Name[d1], dDrug2Name[d2], rscore[ii]))
fout.write("\n_________\n")
fout.close()
def train(self, dataWrapper, iFold, method="New", printDB=params.PRINT_DB):
realData = dataWrapper.data
target = dataWrapper.x
model = WHGNN(realData.featureSize, params.EMBEDDING_SIZE, realData.nSe, realData.nD, device=self.device)
self.model = model.to(self.device)
if params.OPTIMIZER == "Adam":
optimizer = torch.optim.Adam(self.model.parameters(), lr=0.01)
else:
optimizer = torch.optim.Adagrad(self.model.parameters(), lr=0.01)
trainTpl, testTpl, validTpl, negTestTpl, negValidTpl = realData.trainFold, realData.testFold, \
realData.validFold, realData.negFold, realData.negFold
sortedADRs = realData.orderADRIds
secs = [set() for _ in range(params.N_SEC)]
secsList = [[] for _ in range(params.N_SEC)]
secLength = int(len(sortedADRs) / params.N_SEC)
for i, v in enumerate(sortedADRs):
secId = int(i / secLength)
if secId == params.N_SEC:
secId = params.N_SEC - 1
secs[secId].add(v + realData.nD)
secsList[secId].append(v + realData.nD)
adrSecIndiceTestPos = self.selectSubIndices(secs, testTpl)
adrSecINdiceTestNeg = self.selectSubIndices(secs, negTestTpl)
if params.EXPORT_TOP_NEG:
print("Exporting TOP NEGs...")
dAdrName, dDrugName = utils.load_obj(params.ID2NamePath)
outFile = "%s/Export_TOP_NEG_%s_%s" % (params.OUTPUT_DIR, method, iFold)
predictedValues = utils.load_obj("%s/SaveCalValues_W_%s_%s" % (params.OUTPUT_DIR, method, iFold))
_, outNegK = predictedValues
ses = secsList[-1][-50:]
dSeId2Tpls, dSeId2Indices = self.loadNegIds(ses, secs, negTestTpl, segId=-1)
self.exportTopNeg(dSeId2Tpls, dSeId2Indices, outNegK, realData.nD, dAdrName, dDrugName, outFile)
exit(-1)
if params.VISUAL:
print("Visualize: ...")
dataX = np.loadtxt("%s%sW_%s" % (params.EMBEDDING_PREX, method, iFold))
wx = np.loadtxt("%s%sW_Weight%s" % (params.EMBEDDING_PREX, method, iFold))
dADR2Name, dDrug2Name = utils.load_obj(params.ID2NamePath)
print(len(dADR2Name), len(dDrug2Name))
dName2DrugId = utils.reverse_dict(dDrug2Name)
drugNamePairs = [[["Diazepam", "Clarithromycin"]],
[["Hydroxyzine", "Warfarin"]],
[["Simvastatin", "Glipizide"]],
[["Prednisone", "Tolterodine"]]]
seIds = sortedADRs[-5:]
drungIdPairs = []
for pList in drugNamePairs:
vv = []
for p in pList:
d1, d2 = p
vv.append([dName2DrugId[d1], dName2DrugId[d2]])
drungIdPairs.append(vv)
for ii, seId in enumerate(seIds):
w = wx[seId]
dataXW = dataX * np.tile(w, (dataX.shape[0], 1))
self.visual2(trainTpl, seId, realData.nD, dataXW, method, [], iFold, dADR2Name, dDrug2Name)
exit(-1)
return 0, 0, 0
A = realData.AFold
D = realData.DFold
print(A.shape, A[0, :10])
print(D.shape, D[:10])
dd = self.convertAllDict2LongList(realData.trainPairStats, model.nV)
# trainIds = torch.from_numpy(np.asarray(trainTpl)).long().to(self.device)
testIds = torch.from_numpy(np.asarray(testTpl)).long().to(self.device)
validIds = torch.from_numpy(np.asarray(validTpl)).long().to(self.device)
negTestIds = torch.from_numpy(np.asarray(negTestTpl)).long().to(self.device)
# negValidIds = torch.from_numpy(np.asarray(negValidTpl)).long()
drugFeatures = torch.from_numpy(realData.drug2Features).float().to(self.device)
arAUCAUPR = []
arAUCVal = []
arSecs = []
startTime = time.time()
finalX = None
nd = min(params.N_SGD, model.nD, model.nSe)
allResValues = []
for i in range(params.N_ITER):
optimizer.zero_grad()
finalX = self.model.forward1(drugFeatures, dd)
vd1, vd2, vd3, sampleTrain = self.model.sampleDims(nsample=nd, toTuple=True)
out = self.model.forward2(finalX, sampleTrain)
out = out.reshape(nd, nd, nd)
targetx = target[vd1, :, :]
targetx = targetx[:, vd2, :]
targetx = targetx[:, :, vd3]
errTrain = self.model.getWLoss(targetx, out)
assert not torch.isnan(errTrain).any()
errTrain.backward()
optimizer.step()
self.model.projectNonNegW()
if i % params.ITER_DB == 0:
print("\r@Iter ", i, end=" ")
print(torch.max(self.model.dimWeightList[0].weight), torch.min(self.model.dimWeightList[0].weight))
print(torch.max(self.model.lastDimWeight.weight), torch.min(self.model.lastDimWeight.weight))
outTest = self.model.forward2(finalX, testIds).cpu().detach().numpy()
outValid = self.model.forward2(finalX, validIds).cpu().detach().numpy()
outNegTest = self.model.forward2(finalX, negTestIds).cpu().detach().numpy()
if params.ON_REAL:
reSec = []
for kk in range(params.N_SEC):
indicePos = adrSecIndiceTestPos[kk]
indiceNeg = adrSecINdiceTestNeg[kk]
outPosK = outTest[indicePos]
outNegK = outNegTest[indiceNeg]
auck, auprk = evalAUCAUPR1(outPosK, outNegK)
reSec.append([auck, auprk])
if (kk == params.N_SEC - 1):
allResValues.append([outPosK, outNegK])
arSecs.append(reSec)
auc, aupr = evalAUCAUPR1(outTest, outNegTest)
arAUCAUPR.append((auc, aupr))
aucv, auprv = evalAUCAUPR1(outValid, outNegTest)
arAUCVal.append(aucv)
cTime = time.time()
self.logger.infoAll((auc, aucv, aupr, "Elapse@:", i, cTime - startTime))
selectedInd = np.argmax(arAUCVal)
auc, aupr = arAUCAUPR[selectedInd]
vv = -1
if params.ON_REAL:
vv = arSecs[selectedInd]
print(vv)
np.savetxt("%s%sW_%s" % (params.EMBEDDING_PREX, method, iFold), finalX.cpu().detach().numpy())
np.savetxt("%s%sW_Weight%s" % (params.EMBEDDING_PREX, method, iFold),
self.model.lastDimWeight.weight.cpu().detach().numpy())
predictedValues = allResValues[selectedInd]
utils.save_obj(predictedValues, "%s/SaveCalValues_W_%s_%s" % (params.OUTPUT_DIR, method, iFold))
return auc, aupr, vv
def evalAUCAUPR1(outPos, outNeg):
s1 = outPos.shape[0]
s2 = outNeg.shape[0]
trueOut = np.zeros(s1 + s2)
for i in range(s1):
trueOut[i] = 1
predicted = np.concatenate((outPos, outNeg))
aupr = average_precision_score(trueOut, predicted)
auc = roc_auc_score(trueOut, predicted)
return auc, aupr
if __name__ == "__main__":
pass | 14,080 | 35.669271 | 117 | py |
CentSmoothieCode | CentSmoothieCode-master/models/runner.py | from utils import utils
from utils.logger.logger2 import MyLogger
from models.trainWeightCentL import WrapperWeightCentSmooth
from dataFactory.datawrapper import Wrapper
import params
import numpy as np
import random
import torch
class Runner:
def __init__(self):
resetRandomSeed()
self.data = None
utils.ensure_dir("%s/logs" % params.C_DIR)
self.wrapper = WrapperWeightCentSmooth()
PREX = "RL_%s_%s" % (params.MAX_R_ADR, params.MAX_R_DRUG)
logPath = "%s/logs/%s_%s_%s_%s" % (
params.C_DIR, PREX, self.wrapper.name, params.L_METHOD, utils.getCurrentTimeString())
self.logger = MyLogger(logPath)
self.wrapper.setLogger(self.logger)
def run(self):
method = params.L_METHOD
aucs = []
auprs = []
aucks = []
auprks = []
self.logger.infoAll(("Laplacian: ", method, " Deg Norm: ", params.DEG_NORM, "N_LAYER: ", params.N_LAYER))
self.logger.infoAll(
("On Weight: ", params.ON_W, "Learn Weight: ", params.LEARN_WEIGHT_IN, params.LEARN_WEIGHT_LAST))
self.logger.infoAll(("On Layer W: ", params.LAYER_WEIGHT))
self.logger.infoAll(("ON REAL: ", params.ON_REAL))
self.logger.infoAll(("Embedding size: ", params.EMBEDDING_SIZE))
self.logger.infoAll(("FORCE CPU: ", params.FORCE_CPU))
self.logger.infoAll(("Visual:", params.VISUAL))
ar = [i for i in range(params.K_FOLD)]
ss = ar
print(ss)
for iFold in ss:
resetRandomSeed()
self.logger.infoAll(("Fold: ", iFold))
wrapper = Wrapper()
wrapper.loadData(iFold)
self.logger.infoAll(("NDRUG, NSE: ", wrapper.data.nD, wrapper.data.nSe))
auc, aupr, vv = self.wrapper.train(wrapper, iFold, method)
if params.VISUAL:
continue
aucs.append(auc)
auprs.append(aupr)
if vv != -1:
vv = np.asarray(vv)
aucks.append(vv[:, 0])
auprks.append(vv[:, 1])
self.logger.infoAll(("AUC, AUPR: ", auc, aupr))
mauc, eauc = getMeanSE(aucs)
maupr, eaupr = getMeanSE(auprs)
self.logger.infoAll(params.L_METHOD)
self.logger.infoAll((mauc, eauc))
self.logger.infoAll((maupr, eaupr))
if len(aucks) > 0:
aucks = np.vstack(aucks)
auprks = np.vstack(auprks)
self.logger.infoAll((getMeanSE2(aucks)))
self.logger.infoAll((getMeanSE2(auprks)))
def getMeanSE(ar):
mean = np.mean(ar)
se = np.std(ar) / np.sqrt(len(ar))
return mean, se
def getMeanSE2(ndar):
mean = np.mean(ndar, axis=0)
se = np.std(ndar, axis=0) / np.sqrt(ndar.shape[0])
return mean, se
def convertArToString(ar):
s = ""
for v in ar:
s += "," + str(v)
return "[" + s[1:] + "]"
def resetRandomSeed():
random.seed(params.TORCH_SEED)
torch.manual_seed(params.TORCH_SEED)
np.random.seed(params.TORCH_SEED)
| 3,053 | 28.085714 | 113 | py |
CentSmoothieCode | CentSmoothieCode-master/dataFactory/MoleculeFactory2.py | from torch_geometric.data import Data, Batch
from utils import utils
import torch
import numpy as np
import params
class ModeculeFactory2:
def __init__(self):
self.__atomElement2Id = dict()
self.moleculeList = list()
self.smile2Graph = utils.load_obj(params.SMILE2GRAPH)
def getAtomIdFromElement(self, ele):
return utils.get_update_dict_index(self.__atomElement2Id, ele)
def convertSMILE2Graph(self, smile):
mol = self.smile2Graph[smile]
nodes = mol._node
edges = mol._adj
nodeFeatures = []
if len(nodes) == 0:
print("Wrong")
print(smile)
exit(-1)
keys = nodes.keys()
keys = sorted(keys)
mapKeys = dict()
for k in keys:
mapKeys[k] = len(mapKeys)
for nodeId in keys:
nodeDict = nodes[nodeId]
element = nodeDict['element']
atomId = self.getAtomIdFromElement(element)
charger = nodeDict['charge']
aromatic = nodeDict['aromatic']
hcount = nodeDict['hcount']
nodeFeature = [element, atomId, charger, aromatic, hcount]
nodeFeatures.append(nodeFeature)
edgeIndex = []
edgeAttr = []
for nodeId, nextNodes in edges.items():
for nextNodeId, edgeInfo in nextNodes.items():
edgeIndex.append([mapKeys[nodeId], mapKeys[nextNodeId]])
edgeAttr.append([edgeInfo['order']])
return [nodeFeatures, edgeIndex, edgeAttr]
def addSMILE(self, smile):
self.moleculeList.append(self.convertSMILE2Graph(smile))
def getNumAtom(self):
return len(self.__atomElement2Id)
def createBatchGraph(self, atomOffset=0):
self.N_ATOM = self.getNumAtom()
self.N_FEATURE = self.N_ATOM
graphList = list()
cc = 0
for modeculeInfo in self.moleculeList:
nodeFeatures, edgIndex, edgeAttr = modeculeInfo
nodeVecs = []
for nodeFeature in nodeFeatures:
element, atomId, charger, aromatic, hcount = nodeFeature
nodeVecs.append(atomId+atomOffset)
cc += len(nodeFeatures)
newEdgIndex = []
for edge in edgIndex:
i1, i2 = edge
newEdgIndex.append([i1, i2])
nodeVecs = np.asarray(nodeVecs)
nodeVecs = torch.from_numpy(nodeVecs).long()
newEdgIndex = torch.from_numpy(np.asarray(newEdgIndex)).long().t().contiguous()
# edgeAttr = torch.from_numpy(np.asarray(edgeAttr)).float()
data = Data(x=nodeVecs, edge_index=newEdgIndex)
graphList.append(data)
self.graphList = graphList
batch = Batch.from_data_list(graphList)
print("Batch molecular graph completed.")
print("Total: ", cc, len(self.moleculeList), cc * 1.0 / len(self.moleculeList))
return batch
| 2,971 | 30.284211 | 91 | py |
CentSmoothieCode | CentSmoothieCode-master/dataFactory/datawrapper.py | import numpy as np
from utils import utils
import params
import torch
class Wrapper:
def __init__(self):
self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
pass
def loadData(self, iFold):
self.iFold = iFold
print("Loading iFold: ", iFold)
folder = params.FOLD_DATA
data = utils.load_obj("%s/_%d_%d_%d_%d" % (
folder, params.MAX_R_ADR, params.MAX_R_DRUG, params.ADR_OFFSET, iFold))
ddiTensor = np.zeros((data.nD, data.nD, data.nSe))
train2Label = data.pTrainPair2Label
test2Label = data.pTestPosLabel
valid2Label = data.pValidPosLabel
negTest2Label = data.pTestNegLabel
indices = []
for edge, label in train2Label.items():
d1, d2 = edge
for l in label:
indices.append((d1, d2, l))
indices.append((d2, d1, l))
# print(d1, d2, l)
ddiTensor[tuple(np.transpose(indices))] = 1
testPosIndices = []
validPosIndices = []
testNegIndices = []
for edge, label in test2Label.items():
d1, d2 = edge
for l in label:
testPosIndices.append((d1, d2, l))
testPosIndices.append((d2, d1, l))
testPosIndices = tuple(np.transpose(testPosIndices))
for edge, label in valid2Label.items():
d1, d2 = edge
for l in label:
validPosIndices.append((d1, d2, l))
validPosIndices.append((d2, d1, l))
validPosIndices = tuple(np.transpose(validPosIndices))
for edge, label in negTest2Label.items():
d1, d2 = edge
for l in label:
testNegIndices.append((d1, d2, l))
testNegIndices.append((d2, d1, l))
testNegIndices = tuple(np.transpose(testNegIndices))
self.ddiTensor = ddiTensor
features = data.drug2Features
if not params.PROTEIN_FEATURE:
features = data.drug2Features[:, :881]
self.features = torch.from_numpy(features).float().to(self.device)
self.x = torch.from_numpy(ddiTensor).float().to(self.device)
self.testNegIndices = testNegIndices
self.validPosIndices = validPosIndices
self.testPosIndices = testPosIndices
self.data = data
| 2,376 | 28.345679 | 83 | py |
CentSmoothieCode | CentSmoothieCode-master/dataFactory/polyADR.py | import params
from utils import utils
import random
import copy
from dataFactory import loadingMap, MoleculeFactory2
from dataFactory.lh import *
from multiprocessing import Process, Value, Queue
from dataFactory.realData import RealData, RealFoldData
import time
import numpy as np
import torch
def loadPubChem():
return utils.load_obj(params.PUBCHEM_FILE)
def loadMonoADR():
fin = open(params.MONO_ADR_FILE)
dDrug2ADRSet = dict()
while True:
line = fin.readline()
if line == "":
break
line = line.strip()
parts = line.split("|")
inchi = parts[1]
adrs = parts[2]
adrSet = set()
for adr in adrs:
adrSet.add(adr)
dDrug2ADRSet[inchi] = adrSet
fin.close()
return dDrug2ADRSet
def loadDrug2Protein(inchies):
dInchi2Id = dict()
for inchi in inchies:
utils.get_update_dict_index(dInchi2Id, inchi)
nDrug = len(dInchi2Id)
drug2ProteinList = loadingMap.loadDrugProteinMap()
proteinListList = sorted(list(drug2ProteinList.values()))
protensSets = set()
protein2Id = dict()
for proteins in proteinListList:
for protein in proteins:
if protein != "":
protensSets.add(protein)
proteinList = list(protensSets)
proteinList = sorted(proteinList)
for protein in proteinList:
utils.get_update_dict_index(protein2Id, protein)
dDrug2ProteinFeatures = dict()
nP = len(protein2Id)
edge_index = []
for drugInchi, proteins in drug2ProteinList.items():
drugId = utils.get_dict(dInchi2Id, drugInchi, -1)
if drugId == -1:
# print("Skip ",drugId)
continue
proteinFeature = np.zeros(nP)
for p in proteins:
piD0 = protein2Id[p]
proteinFeature[piD0] = 1
pId = piD0 + nDrug
edge_index.append([drugId, pId])
edge_index.append([pId, drugId])
dDrug2ProteinFeatures[drugInchi] = proteinFeature
return edge_index, protein2Id, nDrug, dDrug2ProteinFeatures
def appendProteinProtein(protein2Id, edg_index, nDrug):
fin = open(params.PPI_FILE)
while True:
line = fin.readline()
if line == "":
break
parts = line.strip().split("\t")
p1 = utils.get_dict(protein2Id, parts[0], -1)
p2 = utils.get_dict(protein2Id, parts[1], -1)
if p1 != -1 and p2 != -1:
edg_index.append([p1 + nDrug, p2 + nDrug])
edg_index.append([p2 + nDrug, p1 + nDrug])
fin.close()
return edg_index
def loadInchi2SMILE():
f = open(params.DRUGBANK_ATC_INCHI)
inchi2SMILE = dict()
while True:
line = f.readline()
if line == "":
break
parts = line.strip().split("\t")
inchi2SMILE[parts[-1]] = parts[4]
f.close()
return inchi2SMILE
def createSubSet():
inchi2FingerPrint = loadPubChem()
inchiKeys = inchi2FingerPrint.keys()
monoADR = loadMonoADR()
fin = open(params.POLY_ADR_FILE)
drugSet = set()
adrSet = set()
drugCount = dict()
adrCount = dict()
drugPair2ADR = dict()
inchi2Drug = dict()
while True:
line = fin.readline()
if line == "":
break
line = line.strip()
parts = line.split("|")
d1, d2, inchi1, inchi2 = parts[0], parts[1], parts[2], parts[3]
if inchi1 not in inchiKeys or inchi2 not in inchiKeys:
continue
adrs = parts[4].split(",")
inchi2Drug[inchi1] = d1
inchi2Drug[inchi2] = d2
drugSet.add(inchi1)
drugSet.add(inchi2)
utils.add_dict_counter(drugCount, inchi1)
utils.add_dict_counter(drugCount, inchi2)
adr1 = utils.get_dict(monoADR, inchi1, set())
adr2 = utils.get_dict(monoADR, inchi2, set())
for adr in adrs:
if adr in adr1 or adr in adr2:
continue
adrSet.add(adr)
utils.add_dict_counter(adrCount, adr)
drugPair2ADR[(inchi1, inchi2)] = adrs
fin.close()
adrCountsSorted = utils.sort_dict(adrCount)
cc = []
for p in adrCountsSorted:
_, v = p
cc.append(v)
# from postprocessing import plotHist
# plotHist.plotHist(cc, 20, "../figs/Hist")
# plotHist.plotHist(cc, 20, "../figs/Hist5000", 5000)
# plotHist.plotHist(cc, 20, "../figs/Hist500", 500)
validADRs = set()
endADR = min(len(adrCountsSorted), params.ADR_OFFSET + params.MAX_R_ADR)
orderedADR = list()
for i in range(params.ADR_OFFSET, endADR):
adr, _ = adrCountsSorted[i]
validADRs.add(adr)
orderedADR.append(adr)
drugCountSorted = utils.sort_dict(drugCount)
validInchi = set()
m = min(len(drugCount), params.MAX_R_DRUG)
for i in range(m):
inchi, _ = drugCountSorted[i]
validInchi.add(inchi)
dADR2Pair = dict()
# Filter by ADRs
allPairs = set()
s1 = 0
for pairs, adrs in drugPair2ADR.items():
inchi1, inchi2 = pairs
if inchi1 in validInchi and inchi2 in validInchi:
for adr in adrs:
if adr in validADRs:
pairs = utils.get_insert_key_dict(dADR2Pair, adr, [])
pairs.append((inchi1, inchi2))
allPairs.add((inchi1, inchi2))
s1 += 1
print("Saving ", s1)
print(len(allPairs), len(drugPair2ADR), len(dADR2Pair))
v = (params.MAX_R_ADR, params.MAX_R_DRUG, dADR2Pair, orderedADR, inchi2FingerPrint)
utils.save_obj(v, params.DUMP_POLY)
return v
def stats():
drugSet, adrSet, drugCount, adrCount, drugPair2ADR, _ = createSubSet()
v1 = utils.sort_dict(drugCount)
v2 = utils.sort_dict(adrCount)
print(v1)
print(v2)
print(len(drugSet), len(adrSet), len(drugPair2ADR))
def filter():
pass
def swap(d1, d2):
if d1 > d2:
d1, d2 = d2, d1
return d1, d2
def genTrueNegTpl(adrId2Pairid, nDrug, nNegPerADR):
negTpls = []
for adrId, pairs in adrId2Pairid.items():
adrId = adrId + nDrug
ni = 0
nx = nNegPerADR * np.log(10) / np.log(len(pairs))
while ni < nx:
d1, d2 = np.random.randint(0, nDrug, 2)
d1, d2 = swap(d1, d2)
pair = (d1, d2)
if pair not in pairs:
ni += 1
negTpls.append((d1, d2, adrId))
return negTpls
def producer(queue, datum):
for data in datum:
dADRId2PairIds, numDrug, numNodes, iFold, numSe, negFold, features, smiles, edgeIndex, nProtein, orderedADRIds = data
testFold = []
trainFold = []
validFold = []
edgeSet = set()
edge2Label = dict()
for adr, pairs in dADRId2PairIds.items():
adr = adr + numDrug
pairs = sorted(list(pairs))
pairs = copy.deepcopy(pairs)
random.seed(params.TORCH_SEED)
random.shuffle(pairs)
nSize = len(pairs)
foldSize = int(nSize / params.K_FOLD)
startTest = iFold * foldSize
endTest = (iFold + 1) * foldSize
if endTest > nSize:
endTest = nSize
if iFold == params.K_FOLD - 1:
startValid = 0
else:
startValid = endTest
endValid = startValid + foldSize
for i in range(nSize):
d1, d2 = pairs[i]
tpl = (d1, d2, adr)
if startTest <= i < endTest:
testFold.append(tpl)
elif startValid <= i < endValid:
validFold.append(tpl)
else:
trainFold.append(tpl)
edgeSet.add((d1, d2))
labels = utils.get_insert_key_dict(edge2Label, (d1, d2), [])
labels.append(adr - numDrug)
if params.DEG_NORM:
A, D = genDegNormAFromTpl(trainFold, numNodes)
UA, UD = genDegNormUAFromTpl(trainFold, numNodes)
else:
A, D = genAFromTpl(trainFold, numNodes)
UA, UD = genUAFromTpl(trainFold, numNodes)
if np.min(D) <= 0:
print(iFold)
print(D)
print("Error. Min D <= 0", np.min(D), np.argmin(D))
exit(-1)
if np.min(UD) <= 0:
print(iFold)
print(UD)
print("Error. Min UD <= 0", np.min(UD))
exit(-1)
pairStats = trainFold2PairStats(trainFold, numDrug)
testPosPair2Label = dict()
validPosPair2Label = dict()
testNegPair2Label = dict()
for tpl in testFold:
d1, d2, adr = tpl
posLabels = utils.get_insert_key_dict(testPosPair2Label, (d1, d2), [])
posLabels.append(adr - numDrug)
for tpl in validFold:
d1, d2, adr = tpl
posLabels = utils.get_insert_key_dict(validPosPair2Label, (d1, d2), [])
posLabels.append(adr - numDrug)
for tpl in negFold:
d1, d2, adr = tpl
negLabels = utils.get_insert_key_dict(testNegPair2Label, (d1, d2), [])
negLabels.append(adr - numDrug)
for edge in edgeSet:
d1, d2 = edge
edgeIndex.append([d1, d2])
edgeIndex.append([d2, d1])
gA, gD = genDegANormFrom2Edges(edgeSet, numDrug)
realFold = RealFoldData(trainFold, testFold, validFold, A, UA, negFold, features)
realFold.nSe = numSe
realFold.nD = numDrug
realFold.DFold = D
realFold.UDFold = UD
realFold.trainPairStats = pairStats
realFold.iFold = iFold
realFold.pEdgeSet = edgeSet
realFold.pTrainPair2Label = edge2Label
realFold.pValidPosLabel = validPosPair2Label
realFold.pTestPosLabel = testPosPair2Label
realFold.pTestNegLabel = testNegPair2Label
realFold.gA = gA
realFold.gD = gD
realFold.batchSMILE = smiles
realFold.ppGraph = edgeIndex
realFold.nPro = nProtein
realFold.orderADRIds = orderedADRIds
# torch.tensor(edgeIndex, dtype=torch.long).t().contiguous()
queue.put(realFold)
def consumer(queue, counter):
while True:
data = queue.get()
if data is None:
print("Receive terminate signal")
break
iFold = data.iFold
utils.save_obj(data, "%s/_%d_%d_%d_%d" % (
params.FOLD_DATA, params.MAX_R_ADR, params.MAX_R_DRUG, params.ADR_OFFSET, iFold))
del data
with counter.get_lock():
counter.value += 1
print("Saving fold: ", iFold, "Total: ", counter.value)
def genBatchAtomGraph(smiles):
moleculeFactory = MoleculeFactory2.ModeculeFactory2()
for smile in smiles:
moleculeFactory.addSMILE(smile)
graphBatch = moleculeFactory.createBatchGraph(atomOffset=0)
return graphBatch
def genSMILESFromInchies(inchies):
inchi2SMILE = loadInchi2SMILE()
allSMILEs = []
for inchi in inchies:
smile = inchi2SMILE[inchi]
allSMILEs.append(smile)
return allSMILEs
def genHyperData():
nADR, nDrug, dADR2Pair, orderedADR, inchi2FingerPrint = utils.load_obj(params.DUMP_POLY)
print(nADR, len(dADR2Pair), nDrug, len(inchi2FingerPrint))
# Convert 2 Id
dADR2Id = dict()
dInchi2Id = dict()
dADRId2PairIds = dict()
adrs = sorted(list(dADR2Pair.keys()))
allPairs = set()
orderedADRIds = list()
for adr in adrs:
adrId = utils.get_update_dict_index(dADR2Id, adr)
pairs = dADR2Pair[adr]
for pair in pairs:
inchi1, inchi2 = pair
d1 = utils.get_update_dict_index(dInchi2Id, inchi1)
d2 = utils.get_update_dict_index(dInchi2Id, inchi2)
d1, d2 = swap(d1, d2)
pairIds = utils.get_insert_key_dict(dADRId2PairIds, adrId, set())
pairIds.add((d1, d2))
allPairs.add((d1, d2))
for oADr in orderedADR:
adrId = dADR2Id[oADr]
orderedADRIds.append(adrId)
print("Drug, ADR, Pairs: ", len(dInchi2Id), len(adrs), len(allPairs))
print("Loading ADR 2 Pair completed")
numDrug = len(dInchi2Id)
numSe = len(dADR2Id)
numNodes = numDrug + numSe
print(numDrug, numSe, numNodes)
# Create Feature Matrix:
dDrugId2Inchi = utils.reverse_dict(dInchi2Id)
allInchies = dDrugId2Inchi.keys()
features = []
inchies = []
for i in range(numDrug):
inchi = dDrugId2Inchi[i]
inchies.append(inchi)
fs = inchi2FingerPrint[inchi]
features.append(fs)
smiles = genSMILESFromInchies(inchies)
edgeIndex, protein2Id, nDrug, dDrug2ProteinFeatures = loadDrug2Protein(inchies)
appendProteinProtein(protein2Id, edgeIndex, nDrug)
nProtein = len(protein2Id)
features = np.vstack(features)
if params.PROTEIN_FEATURE:
pFeatures = []
for inchi in inchies:
try:
ff = dDrug2ProteinFeatures[inchi]
except:
ff = np.zeros(nProtein)
pFeatures.append(ff)
pFeatures = np.vstack(pFeatures)
features = np.concatenate((features, pFeatures), axis=1)
negFold = genTrueNegTpl(dADRId2PairIds, numDrug, params.SAMPLE_NEG)
producers = []
consumers = []
queue = Queue(params.K_FOLD)
counter = Value('i', 0)
foldPerWorker = int(params.S_KFOLD / params.N_DATA_WORKER)
for i in range(params.N_DATA_WORKER):
startFold = i * foldPerWorker
endFold = (i + 1) * foldPerWorker
endFold = min(endFold, params.K_FOLD)
datums = []
for iFold in range(startFold, endFold):
edgeIndex2 = copy.deepcopy(edgeIndex)
data = dADRId2PairIds, numDrug, numNodes, iFold, numSe, negFold, features, smiles, edgeIndex2, nProtein, orderedADRIds
datums.append(data)
producers.append(Process(target=producer, args=(queue, datums)))
for _ in range(4):
p = Process(target=consumer, args=(queue, counter))
p.daemon = True
consumers.append(p)
print("Start Producers...")
for p in producers:
p.start()
print("Start Consumers...")
for p in consumers:
p.start()
for p in producers:
p.join()
print("Finish Producers")
while counter.value < params.S_KFOLD:
time.sleep(0.01)
continue
for _ in range(params.N_DATA_WORKER):
queue.put(None)
print("Finish Consumers")
def trainFold2PairStats(trainFold, nOffDrug):
dii = dict()
dij = dict()
dit = dict()
dtt = dict()
for tpl in trainFold:
i, j, t = tpl
to = t - nOffDrug
i, j = swap(i, j)
vdii = utils.get_insert_key_dict(dii, (i, i), [])
vdii.append(to)
vdjj = utils.get_insert_key_dict(dii, (j, j), [])
vdjj.append(to)
vdji = utils.get_insert_key_dict(dij, (i, j), [])
vdji.append(to)
vdtt = utils.get_insert_key_dict(dtt, (t, t), [])
vdtt.append(to)
vdit = utils.get_insert_key_dict(dit, (i, t), [])
vdit.append(to)
vdjt = utils.get_insert_key_dict(dit, (j, t), [])
vdjt.append(to)
def dict2Array(d):
d2 = dict()
for k, v in d.items():
v = np.asarray(v, dtype=int)
d2[k] = v
return d2
return dict2Array(dii), dict2Array(dij), dict2Array(dit), dict2Array(dtt)
def saveId2Name():
params.ON_REAL = True
params.DEG_NORM = True
print("DEG NORM: ", params.DEG_NORM)
print("DRUG, ADR: ", params.MAX_R_DRUG, params.MAX_R_ADR)
createSubSet()
nADR, nDrug, dADR2Pair, orderedADR, inchi2FingerPrint = utils.load_obj(params.DUMP_POLY)
print(nADR, len(dADR2Pair), nDrug, len(inchi2FingerPrint))
# Convert 2 Id
dADR2Id = dict()
dInchi2Id = dict()
dADRId2PairIds = dict()
adrs = sorted(list(dADR2Pair.keys()))
allPairs = set()
orderedADRIds = list()
for adr in adrs:
adrId = utils.get_update_dict_index(dADR2Id, adr)
pairs = dADR2Pair[adr]
for pair in pairs:
inchi1, inchi2 = pair
d1 = utils.get_update_dict_index(dInchi2Id, inchi1)
d2 = utils.get_update_dict_index(dInchi2Id, inchi2)
d1, d2 = swap(d1, d2)
pairIds = utils.get_insert_key_dict(dADRId2PairIds, adrId, set())
pairIds.add((d1, d2))
allPairs.add((d1, d2))
id2ADr = utils.reverse_dict(dADR2Id)
id2Inchi = utils.reverse_dict(dInchi2Id)
fin = open(params.DRUGBANK_ATC_INCHI)
dINCHI2Name = dict()
while True:
line = fin.readline()
if line == "":
break
line = line.strip()
parts = line.split("\t")
dINCHI2Name[parts[-1]] = parts[1]
fin.close()
dId2DrugName = dict()
for i in range(len(id2Inchi)):
dId2DrugName[i] = dINCHI2Name[id2Inchi[i]]
utils.save_obj((id2ADr, dId2DrugName), params.ID2NamePath)
def getBackId(s, d1x, d2x):
id2ADr, dId2DrugName = utils.load_obj(params.ID2NamePath)
print("S_", s, id2ADr[s])
print("D_", d1x, dId2DrugName[d1x])
print("D_", d2x, dId2DrugName[d2x])
def exportData():
params.ON_REAL = True
params.DEG_NORM = True
print("DEG NORM: ", params.DEG_NORM)
print("DRUG, ADR: ", params.MAX_R_DRUG, params.MAX_R_ADR)
createSubSet()
genHyperData()
saveId2Name()
# v = utils.load_obj(params.R_DATA)
# print(v)
if __name__ == "__main__":
# getBackId(900, 96, 265)
saveId2Name()
| 17,613 | 28.753378 | 130 | py |
nnsvs | nnsvs-master/setup.py | from importlib.machinery import SourceFileLoader
from os.path import exists
from setuptools import find_packages, setup
version = SourceFileLoader("nnsvs.version", "nnsvs/version.py").load_module().version
packages = find_packages()
if exists("README.md"):
with open("README.md", "r", encoding="UTF-8") as fh:
LONG_DESC = LONG_DESC = fh.read()
else:
LONG_DESC = ""
setup(
name="nnsvs",
version=version,
description="DNN-based singing voice synthesis library",
long_description=LONG_DESC,
long_description_content_type="text/markdown",
package_data={"": ["_example_data/*"]},
packages=packages,
include_package_data=True,
install_requires=[
"numpy",
"scipy",
"cython",
"torch >= 1.6.0",
"torchaudio",
"hydra-core >= 1.1.0, < 1.2.0",
"hydra_colorlog >= 1.1.0",
"librosa >= 0.7.0",
"pysptk",
"pyworld",
"tensorboard",
"nnmnkwii",
"pysinsy",
"pyloudnorm",
],
extras_require={
"dev": [
# NOTE: tentative fix for https://github.com/nnsvs/nnsvs/issues/191
"matplotlib<3.6.0",
"seaborn",
"mlflow",
"optuna",
"hydra-optuna-sweeper",
"protobuf <= 3.20.1",
"praat-parselmouth",
],
"docs": [
"sphinx",
"sphinx-autobuild",
"sphinx_rtd_theme",
"nbsphinx>=0.8.6",
"sphinxcontrib-bibtex",
"sphinxcontrib-youtube",
"Jinja2>=3.0.1,<=3.0.3",
"pandoc",
"ipython",
"jupyter",
"matplotlib>=1.5",
],
"lint": [
"pysen",
"types-setuptools",
"mypy<=0.910",
"black>=19.19b0,<=20.8",
"flake8>=3.7,<4",
"flake8-bugbear",
"isort>=4.3,<5.2.0",
"click<8.1.0",
"importlib-metadata<5.0",
],
"test": ["pytest"],
},
entry_points={
"console_scripts": [
"nnsvs-prepare-features = nnsvs.bin.prepare_features:entry",
"nnsvs-prepare-static-features = nnsvs.bin.prepare_static_features:entry",
"nnsvs-prepare-voc-features = nnsvs.bin.prepare_voc_features:entry",
"nnsvs-fit-scaler = nnsvs.bin.fit_scaler:entry",
"nnsvs-preprocess-normalize = nnsvs.bin.preprocess_normalize:entry",
"nnsvs-train = nnsvs.bin.train:entry",
"nnsvs-train-acoustic = nnsvs.bin.train_acoustic:entry",
"nnsvs-train-postfilter = nnsvs.bin.train_postfilter:entry",
"nnsvs-generate = nnsvs.bin.generate:entry",
"nnsvs-gen-static-features = nnsvs.bin.gen_static_features:entry",
"nnsvs-synthesis = nnsvs.bin.synthesis:entry",
],
},
)
| 2,891 | 30.096774 | 86 | py |
nnsvs | nnsvs-master/recipes/_common/clean_checkpoint_state.py | import argparse
import os
import sys
import torch
def get_parser():
parser = argparse.ArgumentParser(
description="Clean checkpoint state and make a new checkpoint",
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
)
parser.add_argument("input_file", type=str, help="input file")
parser.add_argument("output_file", type=str, help="output file")
return parser
if __name__ == "__main__":
args = get_parser().parse_args(sys.argv[1:])
checkpoint = torch.load(args.input_file, map_location=torch.device("cpu"))
size = os.path.getsize(args.input_file)
print("Processisng:", args.input_file)
print(f"File size (before): {size / 1024/1024:.3f} MB")
for k in ["optimizer_state", "lr_scheduler_state"]:
if k in checkpoint.keys():
del checkpoint[k]
# For https://github.com/kan-bayashi/ParallelWaveGAN
for k in ["optimizer", "lr_scheduler", "scheduler"]:
if k in checkpoint.keys():
del checkpoint[k]
if "model" in checkpoint and "discriminator" in checkpoint["model"]:
del checkpoint["model"]["discriminator"]
torch.save(checkpoint, args.output_file)
size = os.path.getsize(args.output_file)
print(f"File size (after): {size / 1024/1024:.3f} MB")
| 1,284 | 31.125 | 78 | py |
nnsvs | nnsvs-master/tests/test_wavenet.py | import torch
from nnsvs.wavenet import WaveNet
def test_wavenet():
x = torch.rand(16, 200, 206)
c = torch.rand(16, 200, 300)
model = WaveNet(in_dim=300, out_dim=206, layers=2)
y = model(c, x)
assert y.shape == x.shape
model.eval()
for T in [10, 20, x.shape[1]]:
y = model.inference(c, num_time_steps=T)
assert y.shape == (16, T, 206)
| 383 | 20.333333 | 54 | py |
nnsvs | nnsvs-master/tests/test_diffusion.py | import pytest
import torch
from nnsvs.base import PredictionType
from nnsvs.diffsinger.denoiser import DiffNet
from nnsvs.diffsinger.diffusion import GaussianDiffusion
from nnsvs.diffsinger.fs2 import FFTBlocks, FFTBlocksEncoder
from nnsvs.model import LSTMEncoder
from nnsvs.util import init_seed
from .util import _test_model_impl
@pytest.mark.parametrize("use_pos_embed", [False, True])
def test_fftblocks(use_pos_embed):
model = FFTBlocks(16, 2, use_pos_embed=use_pos_embed)
B = 4
T = 100
init_seed(B * T)
x = torch.rand(B, T, 16)
lengths = torch.Tensor([T] * B).long()
y_hat = model(x, lengths)
assert x.shape[1] == y_hat.shape[1]
@pytest.mark.parametrize("reduction_factor", [1, 4])
@pytest.mark.parametrize("downsample_by_conv", [False, True])
def test_fs2(reduction_factor, downsample_by_conv):
params = {
"in_dim": 86,
"hidden_dim": 16,
"out_dim": 16,
"num_layers": 2,
"ffn_kernel_size": 3,
"reduction_factor": reduction_factor,
"downsample_by_conv": downsample_by_conv,
}
model = FFTBlocksEncoder(**params)
assert model.prediction_type() == PredictionType.DETERMINISTIC
_test_model_impl(model, params["in_dim"], params["out_dim"])
def test_denoiser():
model = DiffNet(
in_dim=80,
encoder_hidden_dim=12,
residual_layers=2,
residual_channels=4,
dilation_cycle_length=4,
)
x = torch.rand(2, 1, 80, 100)
cond = torch.rand(2, 12, 100)
step = torch.randint(0, 100, (2,))
y = model(x, step, cond)
assert x.shape == y.shape
@pytest.mark.parametrize("pndm_speedup", [None])
def test_gaussian_diffusion(pndm_speedup):
encoder = LSTMEncoder(
in_dim=60,
hidden_dim=2,
out_dim=16,
num_layers=2,
dropout=0.5,
init_type="none",
)
params = {
"in_dim": 60,
"out_dim": 80,
"denoise_fn": DiffNet(
in_dim=80,
encoder_hidden_dim=16,
residual_layers=2,
residual_channels=4,
dilation_cycle_length=4,
),
"K_step": 100,
"betas": None,
"pndm_speedup": pndm_speedup,
}
model = GaussianDiffusion(**params)
B = 4
T = 100
init_seed(B * T)
x = torch.rand(B, T, model.in_dim)
y = torch.rand(B, T, model.out_dim)
lengths = torch.Tensor([T] * B).long()
encoder_outs = encoder(x, lengths)
noise, x_recon = model(encoder_outs, lengths, y)
assert noise.shape == y.shape
assert x_recon.shape == y.shape
y_hat = model.inference(encoder_outs, lengths)
assert y_hat.shape == y.shape
@pytest.mark.parametrize("pndm_speedup", [None])
def test_gaussian_diffusion_with_encoder(pndm_speedup):
params = {
"in_dim": 60,
"out_dim": 80,
"denoise_fn": DiffNet(
in_dim=80,
encoder_hidden_dim=16,
residual_layers=2,
residual_channels=4,
dilation_cycle_length=4,
),
"encoder": LSTMEncoder(
in_dim=60,
hidden_dim=2,
out_dim=16,
num_layers=2,
dropout=0.5,
init_type="none",
),
"K_step": 100,
"betas": None,
"pndm_speedup": pndm_speedup,
}
model = GaussianDiffusion(**params)
B = 4
T = 100
init_seed(B * T)
x = torch.rand(B, T, model.encoder.in_dim)
y = torch.rand(B, T, model.out_dim)
lengths = torch.Tensor([T] * B).long()
noise, x_recon = model(x, lengths, y)
assert noise.shape == y.shape
assert x_recon.shape == y.shape
y_hat = model.inference(x, lengths)
assert y_hat.shape == y.shape
| 3,725 | 26.80597 | 66 | py |
nnsvs | nnsvs-master/tests/test_postfilters.py | import pytest
import torch
from nnsvs.postfilters import Conv2dPostFilter, MovingAverage1d, MultistreamPostFilter
from nnsvs.util import init_seed
def _test_model_impl(model, in_dim):
B = 4
T = 100
init_seed(B * T)
x = torch.rand(B, T, in_dim)
lengths = torch.Tensor([T] * B).long()
# warmup forward pass
with torch.no_grad():
y = model(x, lengths)
y_inf = model.inference(x, lengths)
assert y.shape == (B, T, in_dim)
assert y.shape == y_inf.shape
@pytest.mark.parametrize("noise_type", ["bin_wise", "frame_wise"])
def test_conv2d_postfilter(noise_type):
params = {
"in_dim": 60,
"channels": 8,
"kernel_size": (3, 3),
"padding_mode": "zeros",
"noise_type": noise_type,
"init_type": "none",
"smoothing_width": 5,
}
model = Conv2dPostFilter(**params)
_test_model_impl(model, params["in_dim"])
@pytest.mark.parametrize("mgc_offset", [0, 1, 2])
@pytest.mark.parametrize("bap_offset", [0, 1])
def test_multistream_postfilter(mgc_offset, bap_offset):
params = {
"channels": 8,
"kernel_size": (3, 3),
"padding_mode": "zeros",
"noise_type": "frame_wise",
"init_type": "none",
}
mgc_postfilter = Conv2dPostFilter(**{**params, "in_dim": 60 - mgc_offset})
bap_postfilter = Conv2dPostFilter(**{**params, "in_dim": 5 - bap_offset})
# (mgc, lf0, vuv, bap)
stream_sizes = [60, 1, 1, 5]
model = MultistreamPostFilter(
mgc_postfilter=mgc_postfilter,
bap_postfilter=bap_postfilter,
lf0_postfilter=None,
stream_sizes=stream_sizes,
mgc_offset=mgc_offset,
bap_offset=bap_offset,
)
_test_model_impl(model, sum(stream_sizes))
@pytest.mark.parametrize("kernel_size", [1, 3, 5])
def test_moving_average_filter(kernel_size):
T = 1000
C = 4
filt = MovingAverage1d(C, C, kernel_size)
x = torch.randn(4, 1, T).expand(4, C, T)
y = filt(x)
assert x.shape == y.shape
# make sure that the same filter is applied across channels
for idx in range(C - 1):
assert (y[0, idx, :] == y[0, idx + 1, :]).all()
filt = MovingAverage1d(1, 1, kernel_size)
x = torch.randn(4, 1, T)
y = filt(x)
assert x.shape == y.shape
| 2,290 | 27.283951 | 86 | py |
nnsvs | nnsvs-master/tests/test_compat.py | from os.path import dirname, join
import hydra
import torch
from nnsvs.model import MDN
from omegaconf import OmegaConf
# https://github.com/r9y9/nnsvs/pull/114#issuecomment-1156631058
def test_mdn_compat():
config = OmegaConf.load(join(dirname(__file__), "data", "mdn_test.yaml"))
model = hydra.utils.instantiate(config.netG)
checkpoint = torch.load(join(dirname(__file__), "data", "mdn_test.pth"))
model.load_state_dict(checkpoint["state_dict"])
assert isinstance(model, MDN)
| 501 | 30.375 | 77 | py |
nnsvs | nnsvs-master/tests/test_mdn.py | import unittest
import numpy as np
import torch
import torch.optim as optim
from nnsvs import mdn
from nnsvs.util import init_seed
from torch import nn
class MDN(nn.Module):
def __init__(self, in_dim, hidden_dim, out_dim, num_layers=1, num_gaussians=30):
super(MDN, self).__init__()
self.first_linear = nn.Linear(in_dim, hidden_dim)
self.hidden_layers = nn.ModuleList(
[nn.Linear(hidden_dim, hidden_dim) for _ in range(num_layers)]
)
self.tanh = nn.Tanh()
self.mdn = mdn.MDNLayer(hidden_dim, out_dim, num_gaussians=num_gaussians)
def forward(self, x, lengths=None):
out = self.tanh(self.first_linear(x))
for hl in self.hidden_layers:
out = self.tanh(hl(out))
return self.mdn(out)
class TestMDN(unittest.TestCase):
@classmethod
def setUpClass(self):
init_seed(42)
# generate data
# Inverse model written in PRML Book p. 273
# https://www.microsoft.com/en-us/research/people/cmbishop/prml-book/
n = 2500
self.d_in = 1
self.d_out = 1
x_train = np.random.uniform(0, 1, (n, self.d_in)).astype(np.float32)
noise = np.random.uniform(-0.1, 0.1, (n, self.d_in)).astype(np.float32)
y_train = x_train + 0.3 * np.sin(2 * np.pi * x_train) + noise
self.x_train_inv = y_train
self.y_train_inv = x_train
self.x_test = np.array([0.0, 0.2, 0.5, 0.8, 1.0]).astype(np.float32)
# [lower_limit, upper_limit] corresponding to x_test
self.y_test_range = np.array(
[[-0.5, 1], [-0.5, 2.0], [0.2, 0.9], [0.8, 1.0], [0.85, 1.05]]
).astype(np.float32)
hidden_dim = 50
num_gaussians = 30
num_layers = 0
self.batch_size = n
use_cuda = torch.cuda.is_available()
self.device = torch.device("cuda" if use_cuda else "cpu")
self.model = MDN(
self.d_in,
hidden_dim,
self.d_out,
num_layers=num_layers,
num_gaussians=num_gaussians,
).to(self.device)
learning_rate = 0.008
self.opt = optim.Adam(self.model.parameters(), lr=learning_rate)
def test_mdn_loss(self):
# wrap up the inverse data as Variables
x = torch.from_numpy(
self.x_train_inv.reshape(self.batch_size, -1, self.d_in)
).to(
self.device
) # (B, max(T), D_in)
y = torch.from_numpy(
self.y_train_inv.reshape(self.batch_size, -1, self.d_out)
).to(
self.device
) # (B, max(T), D_out)
for e in range(1000):
self.model.zero_grad()
pi, sigma, mu = self.model(x)
loss = mdn.mdn_loss(pi, sigma, mu, y).mean()
if e % 100 == 0:
print(f"loss: {loss.data.item()}")
loss.backward()
self.opt.step()
def test_mdn_get_most_probable_sigma_and_mu(self):
self.test_mdn_loss()
pi, sigma, mu = self.model(
torch.from_numpy(self.x_test.reshape(1, -1, self.d_in)).to(self.device)
)
_, max_mu = mdn.mdn_get_most_probable_sigma_and_mu(pi, sigma, mu)
max_mu = max_mu.squeeze(0).cpu().detach().numpy()
print(max_mu.shape)
for i, sample in enumerate(max_mu):
lower_limit = self.y_test_range[i][0]
upper_limit = self.y_test_range[i][1]
assert lower_limit < sample and upper_limit > sample
print(
f"sample: {sample}, lower_limit: {lower_limit}, upper_limit: {upper_limit}"
)
def test_mdn_get_sample(self):
self.test_mdn_loss()
pi, sigma, mu = self.model(
torch.from_numpy(self.x_test.reshape(1, -1, self.d_in)).to(self.device)
)
samples = mdn.mdn_get_sample(pi, sigma, mu).squeeze(0).cpu().detach().numpy()
for i, sample in enumerate(samples):
lower_limit = self.y_test_range[i][0]
upper_limit = self.y_test_range[i][1]
assert lower_limit < sample and upper_limit > sample
print(
f"sample: {sample}, lower_limit: {lower_limit}, upper_limit: {upper_limit}"
)
if __name__ == "__main__":
unittest.main()
| 4,301 | 31.590909 | 91 | py |
nnsvs | nnsvs-master/tests/util.py | import torch
from nnsvs.base import PredictionType
from nnsvs.util import init_seed
def _test_model_impl(model, in_dim, out_dim):
B = 4
T = 100
init_seed(B * T)
x = torch.rand(B, T, in_dim)
y = torch.rand(B, T, out_dim)
lengths = torch.Tensor([T] * B).long()
# warmup forward pass
with torch.no_grad():
outs = model(x, lengths, y)
if model.has_residual_lf0_prediction():
y, lf0_residual = outs
else:
y, lf0_residual = outs, None
y_inf = model.inference(x, lengths)
# Hybrid (MDN + non-MDN)
if model.prediction_type() == PredictionType.MULTISTREAM_HYBRID:
# TODO
pass
# MDN case
elif model.prediction_type() == PredictionType.PROBABILISTIC:
log_pi, log_sigma, mu = y
num_gaussian = log_pi.shape[2]
assert mu.shape == (B, T, num_gaussian, out_dim)
assert log_sigma.shape == (B, T, num_gaussian, out_dim)
if lf0_residual is not None:
assert lf0_residual.shape == (B, T, num_gaussian)
# NOTE: infernece output shouldn't have num_gaussian axis
mu_inf, sigma_inf = y_inf
assert mu_inf.shape == (B, T, out_dim)
assert sigma_inf.shape == (B, T, out_dim)
else:
if lf0_residual is not None:
if isinstance(lf0_residual, list):
lf0_residual = lf0_residual[-1]
assert lf0_residual.shape == (B, T, 1)
# NOTE: some models have multiple outputs (e.g. Tacotron)
if isinstance(y, list):
y = y[-1]
assert y.shape == (B, T, out_dim)
assert y.shape == y_inf.shape
| 1,647 | 32.632653 | 68 | py |
nnsvs | nnsvs-master/tests/test_discriminators.py | import pytest
import torch
from nnsvs.discriminators import Conv2dD
from nnsvs.util import init_seed
def _test_model_impl(model, in_dim):
B = 4
T = 100
init_seed(B * T)
x = torch.rand(B, T, in_dim)
lengths = torch.Tensor([T] * B).long()
# warmup forward pass
with torch.no_grad():
y = model(x, lengths=lengths)
# should contain multiple outputs
assert isinstance(y, list)
# should contain intermediate outputs to compute feature matching loss
assert isinstance(y[-1], list)
@pytest.mark.parametrize("padding_mode", ["reflect", "zeros"])
def test_conv2d(padding_mode):
params = {
"in_dim": 60,
"channels": 8,
"kernel_size": (3, 3),
"padding": (0, 0),
"padding_mode": padding_mode,
"last_sigmoid": False,
"init_type": "none",
}
model = Conv2dD(**params)
_test_model_impl(model, params["in_dim"])
| 923 | 24.666667 | 74 | py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.