def test_smoothed(self):
import numpy as np
import parsimony.utils.consts as consts
from parsimony.functions import CombinedFunction
import parsimony.algorithms.proximal as proximal
import parsimony.functions.losses as losses
import parsimony.functions.penalties as penalties
import parsimony.functions.nesterov as nesterov
import parsimony.utils.start_vectors as start_vectors
import parsimony.datasets.simulate.l1_l2_tv as l1_l2_tv
start_vector = start_vectors.RandomStartVector(normalise=True)
np.random.seed(42)
n, p = 75, 100
penalty_start = 0
alpha = 0.9
Sigma = alpha * np.eye(p, p) \
+ (1.0 - alpha) * np.random.randn(p, p)
mean = np.zeros(p)
M = np.random.multivariate_normal(mean, Sigma, n)
e = np.random.randn(n, 1)
beta = start_vector.get_vector(p)
beta[np.abs(beta) < 0.1] = 0.0
l = 0.618
k = 0.0
g = 0.0
mu_min = 0.001 # consts.TOLERANCE
A = np.eye(p)
A = [A, A, A]
snr = 100.0
X, y, beta_star = l1_l2_tv.load(l, k, g, beta, M, e, A, snr=snr)
function = CombinedFunction()
function.add_function(losses.LinearRegression(X, y,
# penalty_start=penalty_start,
mean=False))
A = nesterov.l1.A_from_variables(p, penalty_start=penalty_start)
function.add_penalty(nesterov.l1.L1(l, A=A, mu=mu_min,
penalty_start=penalty_start))
# function.add_prox(penalties.L1(l, penalty_start=penalty_start))
fista = proximal.FISTA(eps=mu_min, max_iter=20000)
beta = fista.run(function, beta)
assert np.linalg.norm(beta - beta_star) < 5e-2
def test_DynamicCONESTA_tv(self):
import numpy as np
np.random.seed(42)
import parsimony.estimators as estimators
import parsimony.functions.nesterov.tv as tv
import parsimony.utils.start_vectors as start_vectors
import parsimony.algorithms.primaldual as primaldual
import parsimony.datasets.simulate.l1_l2_tv as l1_l2_tv
start_vector = start_vectors.RandomStartVector(normalise=True,
limits=(-1, 1))
px = 1
py = 10
pz = 10
shape = (pz, py, px)
n, p = 75, np.prod(shape)
l = 0.618
k = 1.0 - l
g = 1.618
snr = 100.0
A, _ = tv.A_from_shape(shape)
alpha = 0.9
Sigma = alpha * np.eye(p, p) \
+ (1.0 - alpha) * np.random.randn(p, p)
mean = np.zeros(p)
M = np.random.multivariate_normal(mean, Sigma, n)
e = np.random.randn(n, 1)
beta = start_vector.get_vector(p)
beta = np.sort(beta, axis=0)
beta[np.abs(beta) < 0.1] = 0.0
X, y, beta_star = l1_l2_tv.load(l, k, g, beta, M, e, A, snr=snr)
eps = 1e-8
max_iter = 5200
mu = None
dynamic = estimators.LinearRegressionL1L2TV(l, k, g, A, mu=mu,
algorithm=primaldual.DynamicCONESTA(),
algorithm_params=dict(eps=eps,
max_iter=max_iter),
mean=False)
dynamic.fit(X, y)
err = dynamic.score(X, y)
# print "err :", err
beta_dynamic = dynamic.beta
dynamic.beta = beta_star
err_star = dynamic.score(X, y)
# print "err*:", err_star
serr = abs(err - err_star)
# print "score diff:", serr
assert_less(serr, 5e-5,
msg="The algorithm did not find a minimiser.")
berr = np.linalg.norm(beta_dynamic - beta_star)
# print "beta diff:", berr
assert_less(berr, 5e-3,
msg="The algorithm did not find a minimiser.")
def test_nonsmooth(self):
from parsimony.functions import CombinedFunction
import parsimony.algorithms.proximal as proximal
import parsimony.functions as functions
import parsimony.functions.nesterov.tv as tv
import parsimony.datasets.simulate.l1_l2_tv as l1_l2_tv
import parsimony.utils.start_vectors as start_vectors
np.random.seed(42)
px = 4
py = 4
pz = 4
shape = (pz, py, px)
n, p = 50, np.prod(shape)
l = 0.0
k = 0.0
g = 1.1
start_vector = start_vectors.RandomStartVector(normalise=True)
beta = start_vector.get_vector(p)
alpha = 1.0
Sigma = alpha * np.eye(p, p) \
+ (1.0 - alpha) * np.random.randn(p, p)
mean = np.zeros(p)
M = np.random.multivariate_normal(mean, Sigma, n)
e = np.random.randn(n, 1)
snr = 100.0
A = tv.linear_operator_from_shape(shape)
X, y, beta_star = l1_l2_tv.load(l=l, k=k, g=g, beta=beta, M=M, e=e,
A=A, snr=snr)
eps = 1e-8
max_iter = 12500
beta_start = start_vector.get_vector(p)
mus = [5e-2, 5e-4, 5e-6, 5e-8]
fista = proximal.FISTA(eps=eps, max_iter=max_iter / len(mus))
beta_parsimony = beta_start
for mu in mus:
# function = functions.LinearRegressionL1L2GL(X, y, l, k, g,
# A=A, mu=mu,
# penalty_start=0)
function = CombinedFunction()
function.add_function(functions.losses.LinearRegression(X, y,
mean=False))
function.add_penalty(tv.TotalVariation(l=g, A=A, mu=mu,
penalty_start=0))
beta_parsimony = fista.run(function, beta_parsimony)
berr = np.linalg.norm(beta_parsimony - beta_star)
# print("berr:", berr)
assert berr < 5e-2
f_parsimony = function.f(beta_parsimony)
f_star = function.f(beta_star)
ferr = abs(f_parsimony - f_star)
# print("ferr:", ferr)
assert ferr < 5e-4
# Test proximal operator
beta_parsimony = beta_start
function = CombinedFunction()
function.add_function(functions.losses.LinearRegression(X, y,
mean=False))
function.add_prox(tv.TotalVariation(l=g, A=A, mu=mu, penalty_start=0))
fista = proximal.FISTA(eps=eps, max_iter=830)
beta_parsimony = fista.run(function, beta_parsimony)
berr = np.linalg.norm(beta_parsimony - beta_star)
# print("berr:", berr)
assert berr < 5e-0
f_parsimony = function.f(beta_parsimony)
f_star = function.f(beta_star)
ferr = abs(f_parsimony - f_star)
# print("ferr:", ferr)
assert ferr < 5e-1
def test_nonsmooth(self):
import numpy as np
import parsimony.utils.consts as consts
from parsimony.functions import CombinedFunction
import parsimony.algorithms.proximal as proximal
import parsimony.functions.losses as losses
import parsimony.functions.nesterov as nesterov
import parsimony.utils.start_vectors as start_vectors
import parsimony.datasets.simulate.l1_l2_tv as l1_l2_tv
start_vector = start_vectors.RandomStartVector(normalise=True)
np.random.seed(42)
n, p = 75, 100
alpha = 0.9
V = np.random.randn(p, p)
Sigma = alpha * np.eye(p, p) \
+ (1.0 - alpha) * np.dot(V.T, V)
mean = np.zeros(p)
M = np.random.multivariate_normal(mean, Sigma, n)
e = np.random.randn(n, 1)
beta_start = start_vector.get_vector(p)
beta_start[np.abs(beta_start) < 0.1] = 0.0
l = 0.618
k = 0.0
g = 0.0
A = np.eye(p)
A = [A, A, A]
snr = 100.0
X, y, beta_star = l1_l2_tv.load(l, k, g, beta_start, M, e, A, snr=snr)
beta = beta_start
for mu in [5e-2, 5e-3, 5e-4, 5e-5]:
function = CombinedFunction()
function.add_loss(losses.LinearRegression(X, y, mean=False))
A = nesterov.l1.linear_operator_from_variables(p, penalty_start=0)
function.add_penalty(nesterov.l1.L1(l, A=A, mu=mu,
penalty_start=0))
fista = proximal.FISTA(eps=consts.TOLERANCE, max_iter=2300)
beta = fista.run(function, beta)
berr = np.linalg.norm(beta - beta_star)
# print "berr:", berr
# assert berr < 5e-2
assert_less(berr, 5e-2, "The found regression vector is not correct.")
# Test proximal operator
beta = beta_start
function = CombinedFunction()
function.add_loss(losses.LinearRegression(X, y, mean=False))
A = nesterov.l1.linear_operator_from_variables(p, penalty_start=0)
# function.add_penalty(nesterov.l1.L1(l, A=A, mu=mu_min,
# penalty_start=penalty_start))
function.add_prox(nesterov.l1.L1(l, A=A, mu=5e-5, penalty_start=0))
fista = proximal.FISTA(eps=consts.TOLERANCE, max_iter=2000)
beta = fista.run(function, beta)
berr = np.linalg.norm(beta - beta_star)
# print "berr:", berr
# assert berr < 5e-0
assert_less(berr, 5e-0, "The found regression vector is not correct.")
def test_nonsmooth(self):
import numpy as np
import parsimony.utils.consts as consts
from parsimony.functions import CombinedFunction
import parsimony.algorithms.proximal as proximal
import parsimony.functions.losses as losses
import parsimony.functions.penalties as penalties
import parsimony.functions.nesterov as nesterov
import parsimony.utils.start_vectors as start_vectors
import parsimony.datasets.simulate.l1_l2_tv as l1_l2_tv
start_vector = start_vectors.RandomStartVector(normalise=True)
np.random.seed(42)
n, p = 75, 100
alpha = 0.9
Sigma = alpha * np.eye(p, p) \
+ (1.0 - alpha) * np.random.randn(p, p)
mean = np.zeros(p)
M = np.random.multivariate_normal(mean, Sigma, n)
e = np.random.randn(n, 1)
beta_start = start_vector.get_vector(p)
beta_start[np.abs(beta_start) < 0.1] = 0.0
l = 0.618
k = 0.0
g = 0.0
A = np.eye(p)
A = [A, A, A]
snr = 100.0
X, y, beta_star = l1_l2_tv.load(l, k, g, beta_start, M, e, A, snr=snr)
beta = beta_start
for mu in [5e-2, 5e-3, 5e-4, 5e-5]:
function = CombinedFunction()
function.add_function(losses.LinearRegression(X, y, mean=False))
A = nesterov.l1.linear_operator_from_variables(p, penalty_start=0)
function.add_penalty(nesterov.l1.L1(l, A=A, mu=mu,
penalty_start=0))
fista = proximal.FISTA(eps=consts.TOLERANCE, max_iter=910)
beta = fista.run(function, beta)
berr = np.linalg.norm(beta - beta_star)
# print "berr:", berr
assert berr < 5e-2
# Test proximal operator
beta = beta_start
function = CombinedFunction()
function.add_function(losses.LinearRegression(X, y, mean=False))
A = nesterov.l1.linear_operator_from_variables(p, penalty_start=0)
# function.add_penalty(nesterov.l1.L1(l, A=A, mu=mu_min,
# penalty_start=penalty_start))
function.add_prox(nesterov.l1.L1(l, A=A, mu=5e-5, penalty_start=0))
fista = proximal.FISTA(eps=consts.TOLERANCE, max_iter=800)
beta = fista.run(function, beta)
berr = np.linalg.norm(beta - beta_star)
# print "berr:", berr
assert berr < 5e-0
def test_smoothed(self):
import numpy as np
import scipy.sparse
from parsimony.functions import CombinedFunction
import parsimony.algorithms.proximal as proximal
import parsimony.functions.losses as losses
import parsimony.functions.nesterov as nesterov
import parsimony.utils.weights as weights
import parsimony.datasets.simulate.l1_l2_tv as l1_l2_tv
start_vector = weights.RandomUniformWeights(normalise=True)
np.random.seed(42)
n, p = 75, 100
penalty_start = 0
alpha = 0.9
V = np.random.randn(p, p)
Sigma = alpha * np.eye(p, p) \
+ (1.0 - alpha) * np.dot(V.T, V)
mean = np.zeros(p)
M = np.random.multivariate_normal(mean, Sigma, n)
e = np.random.randn(n, 1)
beta = start_vector.get_weights(p)
beta[np.abs(beta) < 0.1] = 0.0
l = 0.618
k = 0.0
g = 0.0
mu_min = 0.001 # consts.TOLERANCE
A = scipy.sparse.eye(p)
# A = np.eye(p)
A = [A, A, A]
snr = 100.0
X, y, beta_star = l1_l2_tv.load(l, k, g, beta, M, e, A, snr=snr)
function = CombinedFunction()
function.add_loss(losses.LinearRegression(X, y, mean=False))
A = nesterov.l1.linear_operator_from_variables(p,
penalty_start=penalty_start)
function.add_penalty(nesterov.l1.L1(l, A=A, mu=mu_min,
penalty_start=penalty_start))
# function.add_prox(penalties.L1(l, penalty_start=penalty_start))
fista = proximal.FISTA(eps=mu_min, max_iter=23500)
beta = fista.run(function, beta)
berr = np.linalg.norm(beta - beta_star)
# print "berr:", berr
# assert berr < 5
assert_less(berr, 5.0, "The found regression vector is not correct.")
# Test proximal operator
function = CombinedFunction()
function.add_loss(losses.LinearRegression(X, y, mean=False))
A = nesterov.l1.linear_operator_from_variables(p,
penalty_start=penalty_start)
function.add_prox(nesterov.l1.L1(l, A=A, mu=mu_min,
penalty_start=penalty_start))
fista = proximal.FISTA(eps=mu_min, max_iter=20000)
beta = fista.run(function, beta)
berr = np.linalg.norm(beta - beta_star)
# print "berr:", berr
# assert berr < 0.1
assert_less(berr, 0.1, "The found regression vector is not correct.")
def test_smoothed(self):
import numpy as np
from parsimony.functions import CombinedFunction
import parsimony.algorithms.proximal as proximal
import parsimony.functions.losses as losses
import parsimony.functions.nesterov as nesterov
import parsimony.utils.start_vectors as start_vectors
import parsimony.datasets.simulate.l1_l2_tv as l1_l2_tv
start_vector = start_vectors.RandomStartVector(normalise=True)
np.random.seed(42)
n, p = 75, 100
penalty_start = 0
alpha = 0.9
V = np.random.randn(p, p)
Sigma = alpha * np.eye(p, p) \
+ (1.0 - alpha) * np.dot(V.T, V)
mean = np.zeros(p)
M = np.random.multivariate_normal(mean, Sigma, n)
e = np.random.randn(n, 1)
beta = start_vector.get_vector(p)
beta[np.abs(beta) < 0.1] = 0.0
l = 0.618
k = 0.0
g = 0.0
mu_min = 0.001 # consts.TOLERANCE
A = np.eye(p)
A = [A, A, A]
snr = 100.0
X, y, beta_star = l1_l2_tv.load(l, k, g, beta, M, e, A, snr=snr)
function = CombinedFunction()
function.add_loss(losses.LinearRegression(X, y, mean=False))
A = nesterov.l1.linear_operator_from_variables(
p, penalty_start=penalty_start)
function.add_penalty(
nesterov.l1.L1(l, A=A, mu=mu_min, penalty_start=penalty_start))
# function.add_prox(penalties.L1(l, penalty_start=penalty_start))
fista = proximal.FISTA(eps=mu_min, max_iter=23500)
beta = fista.run(function, beta)
berr = np.linalg.norm(beta - beta_star)
# print "berr:", berr
# assert berr < 5
assert_less(berr, 5.0, "The found regression vector is not correct.")
# Test proximal operator
function = CombinedFunction()
function.add_loss(losses.LinearRegression(X, y, mean=False))
A = nesterov.l1.linear_operator_from_variables(
p, penalty_start=penalty_start)
function.add_prox(
nesterov.l1.L1(l, A=A, mu=mu_min, penalty_start=penalty_start))
fista = proximal.FISTA(eps=mu_min, max_iter=20000)
beta = fista.run(function, beta)
berr = np.linalg.norm(beta - beta_star)
# print "berr:", berr
# assert berr < 0.1
assert_less(berr, 0.1, "The found regression vector is not correct.")
