diff --git a/.github/workflows/build_test_package.yml b/.github/workflows/build_test_package.yml index d3077da..c6e73a8 100644 --- a/.github/workflows/build_test_package.yml +++ b/.github/workflows/build_test_package.yml @@ -53,10 +53,9 @@ jobs: - name: Test run: | - pytest - pytest --doctest-modules + pytest --doctest-modules multidms tests - name: Test docs build run: | make -C docs clean - make -C docs html \ No newline at end of file + make -C docs html diff --git a/.github/workflows/publish_package_pypi.yml b/.github/workflows/publish_package_pypi.yml index f851a13..9725cbd 100644 --- a/.github/workflows/publish_package_pypi.yml +++ b/.github/workflows/publish_package_pypi.yml @@ -49,7 +49,8 @@ jobs: - name: Test run: | - pytest + pytest multidms tests + # pytest --doctest-modules multidms tests - name: Build python package run: | diff --git a/.gitignore b/.gitignore index 1500222..3e2e33c 100644 --- a/.gitignore +++ b/.gitignore @@ -7,8 +7,6 @@ Attic/ docs/multidms*rst .vscode -notebooks/output/ - # Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] diff --git a/multidms/__init__.py b/multidms/__init__.py index d4d6001..def7b2c 100644 --- a/multidms/__init__.py +++ b/multidms/__init__.py @@ -50,10 +50,10 @@ class works to compose, compile, and optimize the model parameters __version__ = "0.4.0" __url__ = "https://github.com/matsengrp/multidms" -from polyclonal.alphabets import AAS # noqa: F401 -from polyclonal.alphabets import AAS_WITHGAP # noqa: F401 -from polyclonal.alphabets import AAS_WITHSTOP # noqa: F401 -from polyclonal.alphabets import AAS_WITHSTOP_WITHGAP # noqa: F401 +from binarymap.binarymap import AAS_NOSTOP as AAS # noqa: F401 +from binarymap.binarymap import AAS_WITHGAP # noqa: F401 +from binarymap.binarymap import AAS_WITHSTOP # noqa: F401 +from binarymap.binarymap import AAS_WITHSTOP_WITHGAP # noqa: F401 from multidms.data import Data # noqa: F401 from multidms.model import Model # noqa: F401 diff --git a/multidms/biophysical.py b/multidms/biophysical.py index fd7cfa3..d322502 100644 --- a/multidms/biophysical.py +++ b/multidms/biophysical.py @@ -35,11 +35,12 @@ import jax.numpy as jnp from jaxopt.loss import huber_loss -from jaxopt.prox import prox_lasso -import jax -# jax.config.update("jax_enable_x64", True) +from multidms.utils import transform +import pyproximal +import jax +jax.config.update("jax_enable_x64", True) r""" +++++++++++++++++++++++++++++ @@ -76,11 +77,7 @@ def additive_model(d_params: dict, X_d: jnp.array): jnp.array Predicted latent phenotypes for each row in ``X_d`` """ - return ( - d_params["beta_naught"] - + d_params["alpha_d"] - + (X_d @ (d_params["beta_m"] + d_params["s_md"])) - ) + return d_params["beta0"] + X_d @ d_params["beta"] r""" @@ -279,9 +276,12 @@ def softplus_activation(d_params, act, lower_bound=-3.5, hinge_scale=0.1, **kwar """ return ( hinge_scale - * (jnp.logaddexp(0, (act - (lower_bound + d_params["gamma_d"])) / hinge_scale)) + # GAMMA + # * (jnp.logaddexp(0, (act - (lower_bound + d_params["gamma_d"])) / hinge_scale)) + * (jnp.logaddexp(0, (act - lower_bound) / hinge_scale)) + lower_bound - + d_params["gamma_d"] + # GAMMA + # + d_params["gamma_d"] ) @@ -320,56 +320,102 @@ def _abstract_epistasis( return t(d_params, g(d_params["theta"], additive_model(d_params, X_h)), **kwargs) -def _lasso_lock_prox( - params, - hyperparams_prox=dict( - lasso_params=None, lock_params=None, upper_bound_theta_ge_scale=None - ), - scaling=1.0, -): +def proximal_box_constraints(params, hyperparameters, *args, **kwargs): """ - Apply lasso and lock constraints to parameters + Proximal operator for box constraints for single condition models. - Parameters - ---------- - params : dict - Dictionary of parameters to constrain - hyperparams_prox : dict - Dictionary of hyperparameters for proximal operators - scaling : float - Scaling factor for lasso penalty + Note that *args, and **kwargs are placeholders for additional arguments + that may be passed to this function by the optimizer. """ - # enforce monotonic epistasis and constrain ge_scale upper limit + ( + ge_scale_upper_bound, + lock_params, + bundle_idxs, + ) = hyperparameters + + params = transform(params, bundle_idxs) + + # clamp theta scale to monotonic, and with optional upper bound if "ge_scale" in params["theta"]: params["theta"]["ge_scale"] = params["theta"]["ge_scale"].clip( - 0, hyperparams_prox["upper_bound_theta_ge_scale"] + 0, ge_scale_upper_bound ) + # Any params to constrain during fit + # clamp beta0 for reference condition in non-scaled parameterization + # (where it's a box constraint) + if lock_params is not None: + for (param, subparam), value in lock_params.items(): + params[param][subparam] = value + + params = transform(params, bundle_idxs) + return params + - if "p_weights_1" in params["theta"]: - params["theta"]["p_weights_1"] = params["theta"]["p_weights_1"].clip(0) - params["theta"]["p_weights_2"] = params["theta"]["p_weights_2"].clip(0) +def proximal_objective(Dop, params, hyperparameters, scaling=1.0): + """ADMM generalized lasso optimization.""" + ( + scale_coeff_lasso_shift, + admm_niter, + admm_tau, + admm_mu, + ge_scale_upper_bound, + lock_params, + bundle_idxs, + ) = hyperparameters + # apply prox + beta_ravel = jnp.vstack(params["beta"].values()).ravel(order="F") + + # see https://pyproximal.readthedocs.io/en/stable/index.html + beta_ravel, shift_ravel = pyproximal.optimization.primal.LinearizedADMM( + pyproximal.L2(b=beta_ravel), + pyproximal.L1(sigma=scaling * scale_coeff_lasso_shift), + Dop, + niter=admm_niter, + tau=admm_tau, + mu=admm_mu, + x0=beta_ravel, + show=False, + ) + + beta = beta_ravel.reshape(-1, len(beta_ravel) // len(params["beta"]), order="F") + shift = shift_ravel.reshape(-1, len(shift_ravel) // len(params["beta"]), order="F") + + # update beta dict + for i, d in enumerate(params["beta"]): + params["beta"][d] = beta[i] + + # update shifts + for i, d in enumerate(params["shift"]): + params["shift"][d] = shift[i] - if hyperparams_prox["lasso_params"] is not None: - for key, value in hyperparams_prox["lasso_params"].items(): - params[key] = prox_lasso(params[key], value, scaling) + # clamp beta0 for reference condition in non-scaled parameterization + # (where it's a box constraint) + params = transform(params, bundle_idxs) + # clamp theta scale to monotonic, and with optional upper bound + if "ge_scale" in params["theta"]: + params["theta"]["ge_scale"] = params["theta"]["ge_scale"].clip( + 0, ge_scale_upper_bound + ) # Any params to constrain during fit - if hyperparams_prox["lock_params"] is not None: - for key, value in hyperparams_prox["lock_params"].items(): - params[key] = value + if lock_params is not None: + for (param, subparam), value in lock_params.items(): + params[param][subparam] = value + + # params["beta0"][params["beta0"].keys()] = 0.0 + params = transform(params, bundle_idxs) return params -def _gamma_corrected_cost_smooth( +def smooth_objective( f, params, data, + scale_coeff_ridge_beta=0.0, + scale_coeff_ridge_ge_scale=0.0, + scale_coeff_ridge_ge_bias=0.0, huber_scale=1, - scale_coeff_ridge_shift=0, - scale_coeff_ridge_beta=0, - scale_coeff_ridge_gamma=0, - scale_coeff_ridge_alpha_d=0, **kwargs, ): """ @@ -386,14 +432,12 @@ def _gamma_corrected_cost_smooth( return the respective binarymap and the row associated target functional scores huber_scale : float Scale parameter for Huber loss function - scale_coeff_ridge_shift : float - Ridge penalty coefficient for shift parameters scale_coeff_ridge_beta : float - Ridge penalty coefficient for beta parameters - scale_coeff_ridge_gamma : float - Ridge penalty coefficient for gamma parameters - scale_coeff_ridge_alpha_d : float - Ridge penalty coefficient for alpha parameters + Ridge penalty coefficient for shift parameters + scale_coeff_ridge_ge_scale : float + Ridge penalty coefficient for global epistasis scale parameter + scale_coeff_ridge_ge_bias : float + Ridge penalty coefficient for global epistasis bias parameter kwargs : dict Additional keyword arguments to pass to the biophysical model function @@ -403,19 +447,18 @@ def _gamma_corrected_cost_smooth( Summed loss across all conditions. """ X, y = data - loss = 0 + huber_cost = 0 + beta_ridge_penalty = 0 # Sum the huber loss across all conditions - # shift_ridge_penalty = 0 for condition, X_d in X.items(): # Subset the params for condition-specific prediction d_params = { + "beta0": params["beta0"][condition], + "beta": params["beta"][condition], + # GAMMA + # "gamma": params["gamma"][condition], "theta": params["theta"], - "beta_m": params["beta"], - "beta_naught": params["beta_naught"], - "s_md": params[f"shift_{condition}"], - "alpha_d": params[f"alpha_{condition}"], - "gamma_d": params[f"gamma_{condition}"], } # compute predictions @@ -423,16 +466,27 @@ def _gamma_corrected_cost_smooth( # compute the Huber loss between observed and predicted # functional scores - loss += huber_loss( - y[condition] + d_params["gamma_d"], y_d_predicted, huber_scale + huber_cost += huber_loss( + # GAMMA + # y[condition] + d_params["gamma"], y_d_predicted, huber_scale + y[condition], + y_d_predicted, + huber_scale, ).mean() # compute a regularization term that penalizes non-zero # parameters and add it to the loss function - loss += scale_coeff_ridge_shift * jnp.sum(d_params["s_md"] ** 2) - loss += scale_coeff_ridge_alpha_d * jnp.sum(d_params["alpha_d"] ** 2) - loss += scale_coeff_ridge_gamma * jnp.sum(d_params["gamma_d"] ** 2) + beta_ridge_penalty += scale_coeff_ridge_beta * (d_params["beta"] ** 2).sum() - loss += scale_coeff_ridge_beta * jnp.sum(params["beta"] ** 2) + huber_cost /= len(X) - return loss + ge_scale_ridge_penalty = ( + scale_coeff_ridge_ge_scale * (params["theta"]["ge_scale"] ** 2).sum() + ) + ge_bias_ridge_penalty = ( + scale_coeff_ridge_ge_bias * (params["theta"]["ge_bias"] ** 2).sum() + ) + + return ( + huber_cost + beta_ridge_penalty + ge_scale_ridge_penalty + ge_bias_ridge_penalty + ) diff --git a/multidms/data.py b/multidms/data.py index 14a7313..cac68f4 100644 --- a/multidms/data.py +++ b/multidms/data.py @@ -8,9 +8,8 @@ """ import os -from functools import partial +from functools import partial, cached_property import warnings -import re import binarymap as bmap import numpy as onp @@ -20,6 +19,7 @@ from tqdm.auto import tqdm from multidms import AAS +from multidms.utils import rereference, split_subs import jax import jax.numpy as jnp @@ -31,29 +31,6 @@ jax.config.update("jax_enable_x64", True) -def split_sub(sub_string): - """String match the wt, site, and sub aa - in a given string denoting a single substitution - """ - pattern = r"(?P[A-Z])(?P[\d\w]+)(?P[A-Z\*])" - match = re.search(pattern, sub_string) - assert match is not None, sub_string - return match.group("aawt"), str(match.group("site")), match.group("aamut") - - -def split_subs(subs_string, parser=split_sub): - """Wrap the split_sub func to work for a - string containing multiple substitutions - """ - wts, sites, muts = [], [], [] - for sub in subs_string.split(): - wt, site, mut = parser(sub) - wts.append(wt) - sites.append(site) - muts.append(mut) - return wts, sites, muts - - class Data: r""" Prep and store one-hot encoding of @@ -192,10 +169,10 @@ class notes. >>> data.mutations_df # doctest: +NORMALIZE_WHITESPACE mutation wts sites muts times_seen_a times_seen_b - 0 M1E M 1 E 1 3.0 - 1 M1W M 1 W 1 0.0 - 2 G3P G 3 P 1 1.0 - 3 G3R G 3 R 1 2.0 + 0 M1E M 1 E 1 3 + 1 M1W M 1 W 1 0 + 2 G3P G 3 P 1 4 + 3 G3R G 3 R 1 2 >>> data.variants_df # doctest: +NORMALIZE_WHITESPACE condition aa_substitutions func_score var_wrt_ref @@ -210,8 +187,6 @@ class notes. 8 b M1E P3R -2.7 G3R M1E """ - counter = 0 - def __init__( self, variants_df: pd.DataFrame, @@ -234,9 +209,10 @@ def __init__( "condition column looks to be numeric type, converting to string", UserWarning, ) - self._conditions = tuple(sorted(variants_df["condition"].astype(str).unique())) - - if str(reference) not in self._conditions: + unique_conditions = set(variants_df["condition"].astype(str)) + if any("." in c for c in unique_conditions): + raise ValueError("condition names cannot contain '.'") + if str(reference) not in unique_conditions: if not isinstance(reference, str): raise ValueError( "reference must be a string, note that if your " @@ -244,7 +220,16 @@ def __init__( "converted to string" ) raise ValueError("reference must be in condition factor levels") + + # set the reference as the first condition. We need it to be first because + # the difference matrix will be constructed with that assumption so the + # parameters are inserted in the correct order in the Model initialization + # non_reference_conditions = unique_conditions - set([reference]) + # self._conditions = tuple([reference] + list(non_reference_conditions)) self._reference = str(reference) + sorted_conditions = sorted(list(unique_conditions)) + self._reference_index = sorted_conditions.index(self._reference) + self._conditions = tuple(sorted_conditions) self._collapse_identical_variants = collapse_identical_variants @@ -300,9 +285,7 @@ def __init__( # Use the "aa_substitutions" to infer the # wild type for each condition - # site_map = pd.DataFrame() site_map = pd.DataFrame(columns=self.conditions) - # print(site_map.info()) for hom, hom_func_df in df.groupby("condition"): if verbose: print(f"inferring site map for {hom}") @@ -464,58 +447,88 @@ def get_nis_from_site_map(site_map): axis=1, ) + df.drop(["wts", "sites", "muts"], axis=1, inplace=True) + self._variants_df = df + # Make BinaryMap representations for each condition allowed_subs = {s for subs in df.var_wrt_ref for s in subs.split()} binmaps, X, y, w = {}, {}, {}, {} + self._bundle_idxs = {} + self._scaled_training_data = {"X": {}, "y": y, "w": w} for condition, condition_func_score_df in df.groupby("condition"): - ref_bmap = bmap.BinaryMap( + cond_bmap = bmap.BinaryMap( condition_func_score_df, substitutions_col="var_wrt_ref", allowed_subs=allowed_subs, alphabet=self.alphabet, sites_as_str=letter_suffixed_sites, ) - binmaps[condition] = ref_bmap - X[condition] = sparse.BCOO.from_scipy_sparse(ref_bmap.binary_variants) + binmaps[condition] = cond_bmap + X[condition] = sparse.BCOO.from_scipy_sparse(cond_bmap.binary_variants) y[condition] = jnp.array(condition_func_score_df["func_score"].values) if "weight" in condition_func_score_df.columns: w[condition] = jnp.array(condition_func_score_df["weight"].values) - df.drop(["wts", "sites", "muts"], axis=1, inplace=True) - self._variants_df = df - self._training_data = {"X": X, "y": y, "w": w} - self._binarymaps = binmaps - self._mutations = tuple(ref_bmap.all_subs) + # next, we need to create a "scaled" dataset + # where the bits are flipped in the one-hot encoding + # for all non identical mutations + # see https://github.com/matsengrp/multidms/issues/156 for more + self._bundle_idxs[condition] = jnp.array( + [ + idx + in cond_bmap.sub_str_to_indices(non_identical_mutations[condition]) + for idx in range(len(cond_bmap.all_subs)) + ] + ) + self._scaled_training_data["X"][condition] = rereference( + X[condition], self._bundle_idxs[condition] + ) + self._mutations = tuple(cond_bmap.all_subs) # initialize single mutational effects df mut_df = pd.DataFrame({"mutation": self._mutations}) - mut_df["wts"], mut_df["sites"], mut_df["muts"] = zip( *mut_df["mutation"].map(self._mutparser.parse_mut) ) - # compute times seen in data - for condition, condition_vars in self._variants_df.groupby("condition"): - times_seen = ( - condition_vars["var_wrt_ref"].str.split().explode().value_counts() + for condition in self._conditions: + # compute times seen in data + # compute the sum of each mutation (column) in the scaled data + times_seen = pd.Series( + self._scaled_training_data["X"][condition].sum(0).todense() ) - if (times_seen == times_seen.astype(int)).all(): - times_seen = times_seen.astype(int) + times_seen.index = cond_bmap.all_subs + + assert (times_seen == times_seen.astype(int)).all() times_seen.index.name = "mutation" times_seen.name = f"times_seen_{condition}" - mut_df = mut_df.merge(times_seen, on="mutation", how="left").fillna(0) + mut_df = mut_df.merge(times_seen, on="mutation", how="left") # .fillna(0) + + # set training data properties + self._training_data = {"X": X, "y": y, "w": w} + self._binarymaps = binmaps self._mutations_df = mut_df - self._name = name if isinstance(name, str) else f"Data-{Data.counter}" - Data.counter += 1 + + self._name = name if isinstance(name, str) else "unnamed" def __repr__(self): """Returns a string representation of the object.""" - return f"{self.__class__.__name__}({self.name})" + return f"{self.__class__.__name__}" - def _str__(self): - """Returns a string representation of the object.""" - return f"{self.__class__.__name__}({self.name})" + def __str__(self): + """ + Returns a string representation of the object with a few helpful + attributes. + """ + return ( + f"{self.__class__.__name__}\n" + f"Name: {self.name}\n" + f"Conditions: {self.conditions}\n" + f"Reference: {self.reference}\n" + f"Number of Mutations: {len(self.mutations)}\n" + f"Number of Variants: {len(self.variants_df)}\n" + ) @property def name(self) -> str: @@ -532,6 +545,11 @@ def reference(self) -> str: """The name of the reference condition.""" return self._reference + @property + def reference_index(self) -> int: + """The index of the reference condition.""" + return self._reference_index + @property def mutations(self) -> tuple: """ @@ -578,6 +596,15 @@ def non_identical_sites(self) -> dict: """ return self._non_identical_sites + @property + def bundle_idxs(self) -> dict: + """ + A dictionary keyed by condition names with values + being the indices into the binarymap representing + bundle (non_identical) mutations + """ + return self._bundle_idxs + @property def reference_sequence_conditions(self) -> list: """ @@ -591,6 +618,11 @@ def training_data(self) -> dict: """A dictionary with keys 'X' and 'y' for the training data.""" return self._training_data + @property + def scaled_training_data(self) -> dict: + """A dictionary with keys 'X' and 'y' for the scaled training data.""" + return self._scaled_training_data + @property def binarymaps(self) -> dict: """ @@ -630,6 +662,34 @@ def parse_muts(self) -> partial: """ return self._parse_muts + @cached_property + def single_mut_encodings(self): + """ + A dictionary keyed by condition names with values + being the one-hot encoding of all single mutations + """ + # all reference sequence conditions encodings are single the identity matrix + single_mut_encodings = { + condition: sparse.BCOO.fromdense(onp.identity(len(self.mutations))) + for condition in self.reference_sequence_conditions + } + # conditions which are not reference sequence conditions must call the + for condition in self.conditions: + if condition in self.reference_sequence_conditions: + continue + single_mut_encodings[condition] = sparse.BCOO.fromdense( + onp.vstack( + [ + self.binarymaps[condition].sub_str_to_binary( + self.convert_subs_wrt_ref_seq(condition, sub) + ) + for sub in self.mutations + ] + ) + ) + + return single_mut_encodings + def convert_subs_wrt_ref_seq(self, condition, aa_subs): """ Covert amino acid substitutions to be with respect to the reference sequence. diff --git a/multidms/model.py b/multidms/model.py index bd0dab2..bc634d0 100644 --- a/multidms/model.py +++ b/multidms/model.py @@ -8,24 +8,26 @@ import math import warnings -from functools import partial, reduce +from functools import lru_cache, partial, cached_property +from frozendict import frozendict + +from multidms import Data +import multidms.biophysical +from multidms.plot import _lineplot_and_heatmap +from multidms.utils import transform, difference_matrix import jax import jax.numpy as jnp import numpy as onp import pandas as pd import scipy -import seaborn as sns -from frozendict import frozendict +import pylops +from scipy.stats import pearsonr from jax.experimental import sparse from jaxopt import ProximalGradient -from jaxopt.linear_solve import solve_normal_cg -from matplotlib import pyplot as plt -from scipy.stats import pearsonr -from multidms import Data -import multidms.biophysical -from multidms.plot import _lineplot_and_heatmap +import seaborn as sns +from matplotlib import pyplot as plt jax.config.update("jax_enable_x64", True) @@ -129,10 +131,10 @@ class Model: >>> model.data.mutations_df # doctest: +NORMALIZE_WHITESPACE mutation wts sites muts times_seen_a times_seen_b - 0 M1E M 1 E 1 3.0 - 1 M1W M 1 W 1 0.0 - 2 G3P G 3 P 1 1.0 - 3 G3R G 3 R 1 2.0 + 0 M1E M 1 E 1 3 + 1 M1W M 1 W 1 0 + 2 G3P G 3 P 1 4 + 3 G3R G 3 R 1 2 However, if accessed directly through the :class:`Model` object, you will get the same information, along with model/parameter specific @@ -140,20 +142,18 @@ class Model: request the property. >>> model.get_mutations_df() # doctest: +NORMALIZE_WHITESPACE - beta shift_b predicted_func_score_a predicted_func_score_b \ - mutation - M1E 0.080868 0.0 0.101030 0.565154 - M1W -0.386247 0.0 -0.476895 -0.012770 - G3P -0.375656 0.0 -0.464124 0.000000 - G3R 1.668974 0.0 1.707195 2.171319 - - times_seen_a times_seen_b wts sites muts + wts sites muts times_seen_a times_seen_b beta_a beta_b shift_b \ mutation - M1E 1 3.0 M 1 E - M1W 1 0.0 M 1 W - G3P 1 1.0 G 3 P - G3R 1 2.0 G 3 R - + M1E M 1 E 1 3 0.0 0.0 0.0 + M1W M 1 W 1 0 0.0 0.0 0.0 + G3P G 3 P 1 4 0.0 -0.0 0.0 + G3R G 3 R 1 2 0.0 0.0 0.0 + predicted_func_score_a predicted_func_score_b + mutation + M1E 0.0 0.0 + M1W 0.0 0.0 + G3P 0.0 0.0 + G3R 0.0 0.0 Notice the respective single mutation effects (``"beta"``), conditional shifts (``shift_d``), @@ -161,27 +161,26 @@ class Model: easily accessible. Similarly, we can take a look at the variants_df for the model, >>> model.get_variants_df() # doctest: +NORMALIZE_WHITESPACE - condition aa_substitutions func_score var_wrt_ref predicted_latent \ - 0 a M1E 2.0 M1E 0.080868 - 1 a G3R -7.0 G3R 1.668974 - 2 a G3P -0.5 G3P -0.375656 - 3 a M1W 2.3 M1W -0.386247 - 4 b M1E 1.0 G3P M1E 0.080868 - 5 b P3R -5.0 G3R 2.044630 - 6 b P3G 0.4 0.375656 - 7 b M1E P3G 2.7 M1E 0.456523 - 8 b M1E P3R -2.7 G3R M1E 2.125498 - + condition aa_substitutions func_score var_wrt_ref predicted_latent \ + 0 a M1E 2.0 M1E 0.0 + 1 a G3R -7.0 G3R 0.0 + 2 a G3P -0.5 G3P 0.0 + 3 a M1W 2.3 M1W 0.0 + 4 b M1E 1.0 G3P M1E 0.0 + 5 b P3R -5.0 G3R 0.0 + 6 b P3G 0.4 0.0 + 7 b M1E P3G 2.7 M1E 0.0 + 8 b M1E P3R -2.7 G3R M1E 0.0 predicted_func_score - 0 0.101030 - 1 1.707195 - 2 -0.464124 - 3 -0.476895 - 4 0.098285 - 5 2.171319 - 6 0.464124 - 7 0.565154 - 8 2.223789 + 0 0.0 + 1 0.0 + 2 0.0 + 3 0.0 + 4 0.0 + 5 0.0 + 6 0.0 + 7 0.0 + 8 0.0 We now have access to the predicted (and gamma corrected) functional scores @@ -192,46 +191,37 @@ class Model: given our initialized parameters >>> model.loss - Array(7.19312981, dtype=float64) + 2.9370000000000003 Next, we fit the model with some chosen hyperparameters. - >>> model.fit(maxiter=1000, lasso_shift=1e-5, warn_unconverged=False) + >>> model.fit(maxiter=10, lasso_shift=1e-5, warn_unconverged=False) >>> model.loss - Array(1.18200934e-05, dtype=float64) + 0.3483478119356665 The model tunes its parameters in place, and the subsequent call to retrieve the loss reflects our models loss given its updated parameters. - - TODO: add more examples, and explain the convergence criteria and warning. """ # noqa: E501 - counter = 0 - def __init__( self, data: Data, epistatic_model=multidms.biophysical.sigmoidal_global_epistasis, output_activation=multidms.biophysical.identity_activation, - conditional_shifts=True, - alpha_d=False, - gamma_corrected=False, + # gamma_corrected=False, PRNGKey=0, lower_bound=None, n_hidden_units=5, - init_beta_naught=0.0, init_theta_scale=5.0, init_theta_bias=-5.0, name=None, ): """See class docstring.""" - self.gamma_corrected = gamma_corrected - self.conditional_shifts = conditional_shifts - self.alpha_d = alpha_d + # self.gamma_corrected = gamma_corrected GAMMA self._data = data - self._params = {} + self._scaled_data_params = {} key = jax.random.PRNGKey(PRNGKey) # initialize beta and shift parameters @@ -240,17 +230,25 @@ def __init__( latent_model = multidms.biophysical.additive_model if latent_model == multidms.biophysical.additive_model: n_beta_shift = len(self._data.mutations) - self._params["beta"] = jax.random.normal(shape=(n_beta_shift,), key=key) - for condition in data.conditions: - self._params[f"shift_{condition}"] = jnp.zeros(shape=(n_beta_shift,)) - self._params[f"alpha_{condition}"] = jnp.zeros(shape=(1,)) - self._params["beta_naught"] = jnp.array([init_beta_naught]) + self._scaled_data_params["beta0"] = { + cond: jnp.zeros(shape=(1,)) for cond in data.conditions + } + self._scaled_data_params["beta"] = { + cond: jnp.zeros(shape=(n_beta_shift,)) for cond in data.conditions + } + self._scaled_data_params["shift"] = { + cond: jnp.zeros(shape=(n_beta_shift,)) for cond in data.conditions + } + # GAMMA + # self._params["gamma"] = { + # cond: jnp.zeros(shape=(1,)) for cond in data.conditions + # } else: raise ValueError(f"{latent_model} not recognized,") # initialize theta parameters if epistatic_model == multidms.biophysical.sigmoidal_global_epistasis: - self._params["theta"] = dict( + self._scaled_data_params["theta"] = dict( ge_scale=jnp.array([init_theta_scale]), ge_bias=jnp.array([init_theta_bias]), ) @@ -263,13 +261,16 @@ def __init__( "with a lower bound specified when using this model." ) - self._params["theta"] = dict( + self._scaled_data_params["theta"] = dict( ge_scale=jnp.array([init_theta_scale]), ge_bias=jnp.array([init_theta_bias]), ) elif epistatic_model == multidms.biophysical.identity_activation: - self._params["theta"] = dict(ghost_param=jnp.zeros(shape=(1,))) + self._scaled_data_params["theta"] = dict( + ge_scale=jnp.zeros(shape=(1,)), + ge_bias=jnp.zeros(shape=(1,)), + ) elif epistatic_model == multidms.biophysical.nn_global_epistasis: if n_hidden_units is None: @@ -277,7 +278,7 @@ def __init__( "n_hidden_units must be specified for nn_global_epistasis" ) key, key1, key2, key3, key4 = jax.random.split(key, num=5) - self._params["theta"] = dict( + self._scaled_data_params["theta"] = dict( p_weights_1=jax.random.normal(shape=(n_hidden_units,), key=key1).clip( 0 ), @@ -303,9 +304,6 @@ def __init__( multidms.biophysical.softplus_activation, lower_bound=lower_bound ) - for condition in data.conditions: - self._params[f"gamma_{condition}"] = jnp.zeros(shape=(1,)) - # compile the model components pred = partial( multidms.biophysical._abstract_epistasis, # abstract function to compile @@ -318,7 +316,13 @@ def __init__( epistatic_model, output_activation, ) - cost = partial(multidms.biophysical._gamma_corrected_cost_smooth, pred) + objective = partial(multidms.biophysical.smooth_objective, pred) + + proximal = ( + multidms.biophysical.proximal_objective + if len(self._data.conditions) > 1 + else multidms.biophysical.proximal_box_constraints + ) self._model_components = frozendict( { @@ -327,37 +331,59 @@ def __init__( "output_activation": output_activation, "f": pred, "from_latent": from_latent, - "objective": cost, - "proximal": multidms.biophysical._lasso_lock_prox, + "objective": objective, + "proximal": proximal, } ) - self._name = name if isinstance(name, str) else f"Model-{Model.counter}" + self._name = name if isinstance(name, str) else "unnamed" # None of the following are set until the fit() is called. self._state = None self._convergence_trajectory = None self._converged = False - Model.counter += 1 def __repr__(self): """Returns a string representation of the object.""" - return f"{self.__class__.__name__}({self.name})" + return f"{self.__class__.__name__}" def __str__(self): - """Returns a string representation of the object.""" - return f"{self.__class__.__name__}({self.name})" + """ + Returns a string representation of the object with a few helpful + attributes. + """ + return ( + f"{self.__class__.__name__}\n" + f"Name: {self.name}\n" + f"Data: {self.data.name}\n" + f"Converged: {self.converged}\n" + ) + + def _clear_cache(self): + """ + identify and clear cached properties. This is useful + after a model has been fit and the parameters have been + updated. + """ + # find all cached properties and clear them + cls = self.__class__ + cached_properties = [ + cp for cp in dir(self) if isinstance(getattr(cls, cp, cls), cached_property) + ] + for a in cached_properties: + self.__dict__.pop(a, None) + + # find all lru_cache methods and call clear_cache on them + for a in dir(self): + attr = getattr(self, a) + if hasattr(attr, "cache_clear"): + attr.cache_clear() @property def name(self) -> str: """The name of the data object.""" return self._name - @property - def params(self) -> dict: - """All current model parameters in a dictionary.""" - return self._params - @property def state(self) -> dict: """The current state of the model.""" @@ -385,56 +411,60 @@ def model_components(self) -> frozendict: return self._model_components @property + def convergence_trajectory_df(self): + """ + The state.error through each training iteration. + Currentlty, this is reset each time the fit() method is called + """ + return self._convergence_trajectory + + @cached_property + def params(self) -> dict: + """A copy of all current model parameters""" + return transform(self._scaled_data_params, self.data.bundle_idxs) + + @cached_property def loss(self) -> float: """ - Compute model loss on all experimental training data + Compute un-penalized model loss on all experimental training data without ridge or lasso penalties included. """ - kwargs = { - "scale_coeff_ridge_beta": 0.0, - "scale_coeff_ridge_shift": 0.0, - "scale_coeff_ridge_gamma": 0.0, - "scale_ridge_alpha_d": 0.0, - } data = (self.data.training_data["X"], self.data.training_data["y"]) - return jax.jit(self.model_components["objective"])(self.params, data, **kwargs) + return float(jax.jit(self.model_components["objective"])(self.params, data)) - @property + @cached_property def conditional_loss(self) -> float: - """Compute loss individually for each condition.""" - kwargs = { - "scale_coeff_ridge_beta": 0.0, - "scale_coeff_ridge_shift": 0.0, - "scale_coeff_ridge_gamma": 0.0, - "scale_ridge_alpha_d": 0.0, - } - + """Compute un-penalized loss individually for each condition.""" X, y = self.data.training_data["X"], self.data.training_data["y"] loss_fxn = jax.jit(self.model_components["objective"]) ret = {} for condition in self.data.conditions: condition_data = ({condition: X[condition]}, {condition: y[condition]}) - ret[condition] = float(loss_fxn(self.params, condition_data, **kwargs)) - ret["total"] = sum(ret.values()) + ret[condition] = float(loss_fxn(self.params, condition_data)) + ret["total"] = sum(ret.values()) / len(ret.values()) return ret - @property - def convergence_trajectory_df(self): + @cached_property + def wildtype_df(self): """ - The state.error through each training iteration. - Currentlty, this is reset each time the fit() method is called + Get a dataframe indexed by condition wildtype + containing the prediction features for each. """ - return self._convergence_trajectory + wildtype_df = ( + pd.DataFrame(index=self.data.conditions) + .assign(predicted_latent=onp.nan) + .assign(predicted_func_score=onp.nan) + ) + for condition in self.data.conditions: + for pheno, model in zip( + ["latent", "func_score"], + [self.latent_fromsubs, self.phenotype_fromsubs], + ): + wildtype_df.loc[condition, f"predicted_{pheno}"] = model("", condition) - @property - def variants_df(self): - """ - Kept for backwards compatibility but will be removed in future versions. - Please use `get_variants_df` instead. - """ - warnings.warn("deprecated", DeprecationWarning) - return self.get_variants_df(phenotype_as_effect=False) + return wildtype_df + @lru_cache(maxsize=3) def get_variants_df(self, phenotype_as_effect=True): """ Training data with model predictions for latent, @@ -457,7 +487,7 @@ def get_variants_df(self, phenotype_as_effect=True): based on the current state of the model. """ # this is what well update and return - variants_df = self._data.variants_df.copy() + variants_df = self.data.variants_df.copy() # initialize new columns for pheno in ["latent", "func_score"]: @@ -465,8 +495,9 @@ def get_variants_df(self, phenotype_as_effect=True): # if we're a gamma corrected model, also report the "corrected" # observed func score, as we do during training. - if self.gamma_corrected: - variants_df["corrected_func_score"] = variants_df["func_score"] + # GAMMA + # if self.gamma_corrected: + # variants_df["corrected_func_score"] = variants_df["func_score"] # get the wildtype predictions for each condition if phenotype_as_effect: @@ -489,42 +520,34 @@ def get_variants_df(self, phenotype_as_effect=True): variants_df.loc[condition_df.index, f"predicted_{pheno}"] = Y_pred - if self.gamma_corrected: - variants_df.loc[condition_df.index, "corrected_func_score"] += d_params[ - "gamma_d" - ] + # GAMMA + # if self.gamma_corrected: + # variants_df.loc[ + # condition_df.index, + # "corrected_func_score" + # ] += d_params[ + # "gamma" + # ] return variants_df - @property - def mutations_df(self): - """ - Kept for backwards compatibility but will be removed in future versions. - Please use `get_mutations_df` instead. - """ - warnings.warn("deprecated", DeprecationWarning) - return self.get_mutations_df(phenotype_as_effect=False) - + @lru_cache(maxsize=3) def get_mutations_df( - self, - phenotype_as_effect=True, - times_seen_threshold=0, - return_split=True, + self, times_seen_threshold=0, phenotype_as_effect=True, return_split=True ): """ - Mutation attributes and phenotypic effects. + Mutation attributes and phenotypic effects + based on the current state of the model. Parameters ---------- - phenotype_as_effect : bool, optional - if True, phenotypes (both latent, and func_score) - are calculated as the _difference_ between predicted - phenotype of a given variant and the respective experimental - wildtype prediction. Otherwise, report the unmodified - model prediction. times_seen_threshold : int, optional Only report mutations that have been seen at least this many times in each condition. Defaults to 0. + phenotype_as_effect : bool, optional + if True, phenotypes are reported as the difference + from the conditional wildtype prediction. Otherwise, + report the unmodified model prediction. return_split : bool, optional If True, return the split mutations as separate columns: 'wts', 'sites', and 'muts'. @@ -536,12 +559,15 @@ def get_mutations_df( A copy of the mutations data, `self.data.mutations_df`, with the mutations column set as the index, and columns with the mutational attributes (e.g. betas, shifts) and - conditional phenotypes (e.g. func_scores) added. - Phenotypes are predicted - based on the current state of the model. + conditional functional score effect (e.g. ) added. + + The columns are ordered as follows: + - beta_a, beta_b, ... : the latent effect of the mutation + - shift_b, shift_c, ... : the conditional shift of the mutation + - predicted_func_score_a, predicted_func_score_b, ... : the + predicted functional score of the mutation. """ - # we're updating this - mutations_df = self.data.mutations_df.set_index("mutation") + mutations_df = self.data.mutations_df.set_index("mutation") # returns a copy if not return_split: mutations_df.drop( ["wts", "sites", "muts"], @@ -561,23 +587,21 @@ def get_mutations_df( i ), f"mutation {sub} df index does not match binarymaps respective index" - # for effect calculation - if phenotype_as_effect: - wildtype_df = self.wildtype_df - - # add betas i.e. 'latent effect' - mutations_df.loc[:, "beta"] = self._params["beta"] - X = sparse.BCOO.fromdense(onp.identity(len(self._data.mutations))) - - for condition in self._data.conditions: - # shift of latent effect + params = self.params + for condition in self.data.conditions: + mutations_df[f"beta_{condition}"] = params["beta"][condition] if condition != self._data.reference: - mutations_df[f"shift_{condition}"] = self._params[f"shift_{condition}"] + mutations_df[f"shift_{condition}"] = params["shift"][condition] + + for condition in self.data.conditions: + single_mut_binary = self.data.single_mut_encodings[condition] + mutations_df[ + f"predicted_func_score_{condition}" + ] = self.phenotype_frombinary(single_mut_binary, condition=condition) - Y_pred = self.phenotype_frombinary(X, condition) if phenotype_as_effect: - Y_pred -= wildtype_df.loc[condition, "predicted_func_score"] - mutations_df[f"predicted_func_score_{condition}"] = Y_pred + wt_func_score = self.wildtype_df.loc[condition, "predicted_func_score"] + mutations_df[f"predicted_func_score_{condition}"] -= wt_func_score # filter by times seen if times_seen_threshold > 0: @@ -586,16 +610,7 @@ def get_mutations_df( mutations_df[f"times_seen_{condition}"] >= times_seen_threshold ] - col_order = ( - ["beta"] - + [c for c in mutations_df.columns if "shift_" in c] - + [c for c in mutations_df.columns if "predicted_" in c] - + [c for c in mutations_df.columns if "times_seen_" in c] - ) - if return_split: - col_order += ["wts", "sites", "muts"] - - return mutations_df[col_order] + return mutations_df def get_df_loss(self, df, error_if_unknown=False, verbose=False, conditional=False): """ @@ -633,6 +648,12 @@ def get_df_loss(self, df, error_if_unknown=False, verbose=False, conditional=Fal if condition_col not in df.columns: raise ValueError("`df` lacks `condition_col` " f"{condition_col}") + kwargs = { + "scale_coeff_ridge_beta": 0.0, + "scale_coeff_ridge_shift": 0.0, + "scale_coeff_ridge_gamma": 0.0, + "scale_ridge_alpha_d": 0.0, + } loss_fxn = jax.jit(self.model_components["objective"]) ret = {} @@ -688,10 +709,9 @@ def get_df_loss(self, df, error_if_unknown=False, verbose=False, conditional=Fal ) y[condition] = jnp.array(variant_targets) + ret[condition] = float(loss_fxn(self.params, (X, y), **kwargs)) - ret[condition] = float(loss_fxn(self.params, (X, y))) - - ret["total"] = sum(ret.values()) + ret["total"] = sum(ret.values()) / len(ret.values()) if not conditional: return ret["total"] @@ -781,6 +801,8 @@ def add_phenotypes_to_df( raise ValueError(f"`df` already contains column {col}") ret[col] = onp.nan + # if the user has provided a name for the converted subs, then + # we need to add it to the dataframe if converted_substitutions_col is not None: ret[converted_substitutions_col] = "" @@ -852,54 +874,41 @@ def add_phenotypes_to_df( return ret - @property - def wildtype_df(self): - """ - Get a dataframe indexed by condition wildtype - containing the prediction features for each. - """ - wildtype_df = ( - pd.DataFrame(index=self.data.conditions) - .assign(predicted_latent=onp.nan) - .assign(predicted_func_score=onp.nan) - ) - for condition in self.data.conditions: - for pheno, model in zip( - ["latent", "func_score"], - [self.latent_fromsubs, self.phenotype_fromsubs], - ): - wildtype_df.loc[condition, f"predicted_{pheno}"] = model("", condition) - - return wildtype_df - - def mutation_site_summary_df(self, agg_func=onp.mean, times_seen_threshold=0): + def mutation_site_summary_df(self, agg_func="mean", **kwargs): """ Get all single mutational attributes from self._data updated with all model specific attributes, then aggregate - all numerical columns by "sites" using - ``agg`` function. The mean values are given by default. + all numerical columns by "sites" + + Parameters + ---------- + agg_func : str + Aggregation function to use on the numerical columns. + Defaults to "mean". + **kwargs + Additional keyword arguments to pass to get_mutations_df. + + Returns + ------- + pandas.DataFrame + A summary of the mutation attributes aggregated by site. """ numerics = ["int16", "int32", "int64", "float16", "float32", "float64"] - mut_df = self.mutations_df.select_dtypes(include=numerics) - times_seen_cols = [c for c in mut_df.columns if "times" in c] - for c in times_seen_cols: - mut_df = mut_df[mut_df[c] >= times_seen_threshold] - - return mut_df.groupby("sites").aggregate(agg_func) + mut_df = self.get_mutations_df(**kwargs).select_dtypes(include=numerics) + return mut_df.groupby("sites").agg(agg_func) def get_condition_params(self, condition=None): """Get the relent parameters for a model prediction""" condition = self.data.reference if condition is None else condition if condition not in self.data.conditions: raise ValueError(f"condition {condition} does not exist in model") - return { + "beta0": self.params["beta0"][condition], + "beta": self.params["beta"][condition], + "shift": self.params["shift"][condition], + # GAMMA + # "gamma": self.params["gamma"][condition], "theta": self.params["theta"], - "beta_m": self.params["beta"], - "beta_naught": self.params["beta_naught"], - "s_md": self.params[f"shift_{condition}"], - "alpha_d": self.params[f"alpha_{condition}"], - "gamma_d": self.params[f"gamma_{condition}"], } def phenotype_fromsubs(self, aa_subs, condition=None): @@ -916,13 +925,13 @@ def phenotype_fromsubs(self, aa_subs, condition=None): ) ] ) - return self.phenotype_frombinary(X, condition) + return float(self.phenotype_frombinary(X, condition)[0]) def latent_fromsubs(self, aa_subs, condition=None): """ take a single string of subs which are not already converted wrt reference, convert them and - then make a latent prediction and return the result. + them make a latent prediction and return the result. """ converted_subs = self.data.convert_subs_wrt_ref_seq(condition, aa_subs) X = jnp.array( @@ -948,7 +957,10 @@ def phenotype_frombinary(self, X, condition=None): Condition to make predictions for. If None, use the reference """ d_params = self.get_condition_params(condition) - return jax.jit(self.model_components["f"])(d_params, X) + if X.shape[0] > 1000: + return jax.jit(self.model_components["f"])(d_params, X) + else: + return self.model_components["f"](d_params, X) def latent_frombinary(self, X, condition=None): """ @@ -966,31 +978,19 @@ def latent_frombinary(self, X, condition=None): d_params = self.get_condition_params(condition) return jax.jit(self.model_components["latent_model"])(d_params, X) - def fit_reference_beta(self, **kwargs): - """ - Fit the Model beta's to the reference data. - - This is an experimental feature and is not recommended - for general use. - """ - ref_X = self.data.training_data["X"][self.data.reference] - ref_y = self.data.training_data["y"][self.data.reference] - - self._params["beta"] = solve_normal_cg( - lambda beta: ref_X @ beta, ref_y, init=self._params["beta"], **kwargs - ) - def fit( self, + scale_coeff_lasso_shift=1e-5, tol=1e-4, maxiter=1000, - acceleration=True, maxls=15, - scale_coeff_lasso_shift=1e-5, + acceleration=True, lock_params={}, + admm_niter=50, + admm_tau=1.0, warn_unconverged=True, - upper_bound_theta_ge_scale="infer", - convergence_trajectory_resolution=100, + upper_bound_ge_scale="infer", + convergence_trajectory_resolution=10, **kwargs, ): r""" @@ -999,9 +999,11 @@ def fit( Parameters ---------- scale_coeff_lasso_shift : float - L1 penalty on the shift parameters. Defaults to 1e-5. + L1 penalty coefficient applied "shift" in beta_d parameters. + Defaults to 1e-4. This parameter is used to regularize the + shift parameters in the model if there's more than one condition. tol : float - Tolerance for the optimization. Defaults to 1e-6. + Tolerance for the optimization convergence criteria. Defaults to 1e-4. maxiter : int Maximum number of iterations for the optimization. Defaults to 1000. maxls : int @@ -1010,14 +1012,20 @@ def fit( If True, use FISTA acceleration. Defaults to True. lock_params : dict Dictionary of parameters, and desired value to constrain - them at during optimization. By default, none of the parameters - besides the reference shift, and reference latent offset are locked. + them at during optimization. By default, no parameters are locked. + admm_niter : int + Number of iterations to perform during the ADMM optimization. + Defaults to 50. Note that in the case of single-condition models, + This is set to zero as the generalized + lasso ADMM optimization is not used. + admm_tau : float + ADMM step size. Defaults to 1.0. warn_unconverged : bool If True, raise a warning if the optimization does not converge. convergence is defined by whether the model tolerance (''tol'') threshold was passed during the optimization process. Defaults to True. - upper_bound_theta_ge_scale : float, None, or 'infer' + upper_bound_ge_scale : float, None, or 'infer' The positive upper bound of the theta scale parameter - negative values are not allowed. Passing ``None`` allows the scale of the sigmoid to be unconstrained. @@ -1029,53 +1037,81 @@ def fit( during optimization. Defaults to 100. **kwargs : dict Additional keyword arguments passed to the objective function. - These include hyperparameters like a ridge penalty on beta, shift, and gamma - as well as huber loss scaling. + See the multidms.biophysical.smooth_objective docstring for + details on the other hyperparameters that may be supplied to + regularize and otherwise modify the objective function + being optimized. """ - lock_params[f"shift_{self._data.reference}"] = jnp.zeros( - len(self._params["beta"]) - ) - lock_params[f"gamma_{self._data.reference}"] = jnp.zeros(shape=(1,)) - - if not self.conditional_shifts: - for condition in self._data.conditions: - lock_params[f"shift_{condition}"] = jnp.zeros(shape=(1,)) - - if not self.gamma_corrected: - for condition in self._data.conditions: - lock_params[f"gamma_{condition}"] = jnp.zeros(shape=(1,)) - - if not self.alpha_d: - for condition in self._data.conditions: - lock_params[f"alpha_{condition}"] = jnp.zeros(shape=(1,)) - else: - lock_params[f"alpha_{self._data.reference}"] = jnp.zeros(shape=(1,)) - - lasso_params = {} - for non_ref_condition in self._data.conditions: - if non_ref_condition == self._data.reference: - continue - lasso_params[f"shift_{non_ref_condition}"] = scale_coeff_lasso_shift - - if not isinstance(upper_bound_theta_ge_scale, (float, int, type(None), str)): + # CONFIG PROXIMAL + # infer the range of the training data, and double it + # to set the upper bound of the theta (post-latent e.g. sigmoid) scale parameter. + # see https://github.com/matsengrp/multidms/issues/143 for details + if not isinstance(upper_bound_ge_scale, (float, int, type(None), str)): raise ValueError( "upper_bound_theta_ge_scale must be a float, None, or 'infer'" ) - if isinstance(upper_bound_theta_ge_scale, (float, int)): - if upper_bound_theta_ge_scale < 0: + if isinstance(upper_bound_ge_scale, (float, int)): + if upper_bound_ge_scale < 0: raise ValueError("upper_bound_theta_ge_scale must be non-negative") - # infer the range of the training data, and double it - # to set the upper bound of the theta scale parameter. - # see https://github.com/matsengrp/multidms/issues/143 for details - # TODO could make this a property of the Data object - if upper_bound_theta_ge_scale == "infer": + if upper_bound_ge_scale == "infer": y = jnp.concatenate(list(self.data.training_data["y"].values())) y_range = y.max() - y.min() - upper_bound_theta_ge_scale = 2 * y_range + upper_bound_ge_scale = 2 * y_range + compiled_proximal = self._model_components["proximal"] compiled_objective = jax.jit(self._model_components["objective"]) - compiled_proximal = jax.jit(self._model_components["proximal"]) + + # if we have more than one condition, we need to set up the ADMM optimization + if len(self.data.conditions) > 1: + non_identical_signs = { + condition: jnp.where(self.data._bundle_idxs[condition], -1, 1) + for condition in self.data.conditions + } + non_identical_sign_matrix = jnp.vstack( + [non_identical_signs[d] for d in self.data.conditions] + ) + diff_matrix = difference_matrix( + len(self.data.conditions), self.data.reference_index + ) + D_block_diag = scipy.sparse.block_diag( + [ + jnp.array(diff_matrix) @ jnp.diag(non_identical_sign_matrix[:, col]) + for col in range(len(self.data.mutations)) + ] + ) + Dop = pylops.LinearOperator( + Op=scipy.sparse.linalg.aslinearoperator(D_block_diag), + dtype=diff_matrix.dtype, + shape=D_block_diag.shape, + ) + eig = jnp.real((Dop.H * Dop).eigs(neigs=1, which="LM")[0]) + + admm_mu = 0.99 * admm_tau / eig + + if len(self.data.conditions) > 1: + assert 0 < admm_mu < admm_tau / eig + + hyperparams_prox = ( + scale_coeff_lasso_shift, + admm_niter, + admm_tau, + admm_mu, + upper_bound_ge_scale, + lock_params, + self.data.bundle_idxs, + ) + + compiled_proximal = partial(self._model_components["proximal"], Dop) + + else: + hyperparams_prox = ( + upper_bound_ge_scale, + lock_params, + self.data.bundle_idxs, + ) + # compiled_proximal = jax.jit(self._model_components["proximal"]) + compiled_proximal = self._model_components["proximal"] solver = ProximalGradient( compiled_objective, @@ -1084,67 +1120,58 @@ def fit( maxiter=maxiter, acceleration=acceleration, maxls=maxls, + jit=False, ) - training_data = (self._data.training_data["X"], self._data.training_data["y"]) + # get training data + scaled_training_data = ( + self._data.scaled_training_data["X"], + self._data.scaled_training_data["y"], + ) self._state = solver.init_state( - self._params, - hyperparams_prox=dict( - lasso_params=lasso_params, - lock_params=lock_params, - upper_bound_theta_ge_scale=upper_bound_theta_ge_scale, - ), - data=training_data, + self._scaled_data_params, + hyperparams_prox=hyperparams_prox, + data=scaled_training_data, **kwargs, ) convergence_trajectory = pd.DataFrame( - index=range(maxiter + 1, convergence_trajectory_resolution) + index=range(0, maxiter + 1, convergence_trajectory_resolution) ).assign(loss=onp.nan, error=onp.nan) - # TODO should step be the index? convergence_trajectory.index.name = "step" # record initial loss and error convergence_trajectory.loc[0, "loss"] = float( - compiled_objective(self._params, training_data) + compiled_objective(self._scaled_data_params, scaled_training_data) ) convergence_trajectory.loc[0, "error"] = float(self._state.error) - # prev_no_pen_obj_loss = jnp.inf for i in range(maxiter): # perform single optimization step - self._params, self._state = solver.update( - self._params, + self._scaled_data_params, self._state = solver.update( + self._scaled_data_params, self._state, - hyperparams_prox=dict( - lasso_params=lasso_params, - lock_params=lock_params, - upper_bound_theta_ge_scale=upper_bound_theta_ge_scale, - ), - data=training_data, + hyperparams_prox=hyperparams_prox, + data=scaled_training_data, **kwargs, ) # record loss and error trajectories at regular intervals if (i + 1) % convergence_trajectory_resolution == 0: - no_pen_obj_loss = float(compiled_objective(self._params, training_data)) - convergence_trajectory.loc[i + 1, "loss"] = no_pen_obj_loss + obj_loss = float( + compiled_objective( + self._scaled_data_params, scaled_training_data, **kwargs + ) + ) + lasso_penalty = scale_coeff_lasso_shift * jnp.sum( + jnp.abs(jnp.vstack(self._scaled_data_params["shift"].values())) + ) + convergence_trajectory.loc[i + 1, "loss"] = obj_loss + lasso_penalty convergence_trajectory.loc[i + 1, "error"] = float(self._state.error) - # TODO, if you wanted to - # delta_no_pen_obj_loss = -1 * (no_pen_obj_loss - prev_no_pen_obj_loss) - # if delta_no_pen_obj_loss < tol: - # self._converged = True - # break - - # prev_no_pen_obj_loss = no_pen_obj_loss - # early stopping criteria - # TODO what if we had an auxilary attribute that we used for - # early stopping, that's probably really speed things up if we - # wanted to do the above. if self._state.error < tol: self._converged = True break @@ -1158,8 +1185,9 @@ def fit( ) self._convergence_trajectory = convergence_trajectory + self._clear_cache() - # return None + return None def plot_pred_accuracy( self, @@ -1176,7 +1204,7 @@ def plot_pred_accuracy( between model predicted functional score of all variants in the training with ground truth measurements. """ - df = self.variants_df + df = self.get_variants_df(phenotype_as_effect=False) df = df.assign( is_wt=df["aa_substitutions"].apply( @@ -1187,7 +1215,9 @@ def plot_pred_accuracy( if ax is None: fig, ax = plt.subplots(figsize=[3, 3]) - func_score = "corrected_func_score" if self.gamma_corrected else "func_score" + # GAMMA + # func_score = "corrected_func_score" if self.gamma_corrected else "func_score" + func_score = "func_score" sns.scatterplot( data=df.sample(frac=1), x="predicted_func_score", @@ -1223,13 +1253,14 @@ def plot_pred_accuracy( c=self._data.condition_colors[c], ) start_y += -0.05 - ax.set_ylabel("functional score") + # ax.set_ylabel("functional score") ax.set_xlabel("predicted functional score") ax.axhline(0, color="k", ls="--", lw=2) ax.axvline(0, color="k", ls="--", lw=2) - ax.set_ylabel("functional score + gamma$_{d}$") + # ax.set_ylabel("functional score + gamma$_{d}$") + ax.set_ylabel("measured functional score") plt.tight_layout() if saveas: fig.savefig(saveas) @@ -1245,7 +1276,7 @@ def plot_epistasis( gamma corrected ground truth measurements of all samples in the training set. """ - df = self.variants_df + df = self.get_variants_df(phenotype_as_effect=False) df = df.assign( is_wt=df["aa_substitutions"].apply( @@ -1256,7 +1287,9 @@ def plot_epistasis( if ax is None: fig, ax = plt.subplots(figsize=[3, 3]) - func_score = "corrected_func_score" if self.gamma_corrected else "func_score" + # GAMMA + # func_score = "corrected_func_score" if self.gamma_corrected else "func_score" + func_score = "func_score" sns.scatterplot( data=df.sample(frac=sample), x="predicted_latent", @@ -1288,7 +1321,7 @@ def plot_epistasis( ax.axhline(0, color="k", ls="--", lw=2) ax.set_xlim([xlb, xub]) ax.set_ylim([ylb, yub]) - ax.set_ylabel("functional score") + ax.set_ylabel("measured functional score") ax.set_xlabel("predicted latent phenotype") plt.tight_layout() @@ -1299,10 +1332,10 @@ def plot_epistasis( return ax def plot_param_hist( - self, param, show=True, saveas=False, times_seen_threshold=3, ax=None, **kwargs + self, param, show=True, saveas=False, times_seen_threshold=0, ax=None, **kwargs ): """Plot the histogram of a parameter.""" - mut_effects_df = self.mutations_df + mut_effects_df = self.get_mutations_df() if ax is None: fig, ax = plt.subplots(figsize=[3, 3]) @@ -1355,18 +1388,18 @@ def plot_param_hist( return ax def plot_param_heatmap( - self, param, show=True, saveas=False, times_seen_threshold=3, ax=None, **kwargs + self, param, show=True, saveas=False, times_seen_threshold=0, ax=None, **kwargs ): """ Plot the heatmap of a parameters associated with specific sites and substitutions. """ - if not param.startswith("beta") and not param.startswith("S"): + if not param.startswith("beta") and not param.startswith("shift"): raise ValueError( "Parameter to visualize must be an existing beta, or shift parameter" ) - mut_effects_df = self.mutations_df + mut_effects_df = self.get_mutations_df() if ax is None: fig, ax = plt.subplots(figsize=[12, 3]) @@ -1402,8 +1435,8 @@ def plot_shifts_by_site( condition, show=True, saveas=False, - times_seen_threshold=3, - agg_func=onp.mean, + times_seen_threshold=0, + agg_func="mean", ax=None, **kwargs, ): @@ -1453,65 +1486,6 @@ def plot_shifts_by_site( plt.show() return ax - def plot_fit_param_comp_scatter( - self, - other, - self_param="beta", - other_param="beta", - figsize=[5, 4], - saveas=None, - show=True, - site_agg_func=None, - ): - """Plot a scatter plot of the parameter values of two models""" - if not site_agg_func: - dfs = [self.mutations_df, other.mutations_df] - else: - dfs = [ - self.mutation_site_summary_df(agg=site_agg_func).reset_index(), - other.mutation_site_summary_df(agg=site_agg_func).reset_index(), - ] - - combine_on = "mutation" if site_agg_func is None else "sites" - comb_mut_effects = reduce( - lambda l, r: pd.merge(l, r, how="inner", on=combine_on), # noqa: E741 - dfs, - ) - comb_mut_effects["is_stop"] = [ - True if "*" in s else False for s in comb_mut_effects[combine_on] - ] - - same = self_param == other_param - x = f"{self_param}_x" if same else self_param - y = f"{other_param}_y" if same else other_param - - fig, ax = plt.subplots(figsize=figsize) - r = pearsonr(comb_mut_effects[x], comb_mut_effects[y])[0] - sns.scatterplot( - data=comb_mut_effects, - x=x, - y=y, - hue="is_stop", - alpha=0.6, - palette="deep", - ax=ax, - ) - - xlb, xub = [-1, 1] + onp.quantile(comb_mut_effects[x], [0.00, 1.0]) - ylb, yub = [-1, 1] + onp.quantile(comb_mut_effects[y], [0.00, 1.0]) - min1 = min(xlb, ylb) - max1 = max(xub, yub) - ax.plot([min1, max1], [min1, max1], ls="--", c="k") - ax.annotate(f"$r = {r:.2f}$", (0.7, 0.1), xycoords="axes fraction", fontsize=12) - plt.tight_layout() - - if saveas: - fig.saveas(saveas) - if show: - plt.show() - - return fig, ax - def mut_param_heatmap( self, mut_param="shift", @@ -1531,7 +1505,13 @@ def mut_param_heatmap( muts_df = self.get_mutations_df( times_seen_threshold=times_seen_threshold, phenotype_as_effect=phenotype_as_effect, - return_split=False, + return_split=True, + ).rename( + columns={ + "wts": "wildtype", + "muts": "mutant", + "sites": "site", + } ) # drop columns which are not the mutational parameter of interest @@ -1541,9 +1521,9 @@ def mut_param_heatmap( muts_df.drop(drop_cols, axis=1, inplace=True) # add in the mutation annotations - muts_df["wildtype"], muts_df["site"], muts_df["mutant"] = zip( - *muts_df.reset_index()["mutation"].map(self.data.parse_mut) - ) + # muts_df["wildtype"], muts_df["site"], muts_df["mutant"] = zip( + # *muts_df.reset_index()["mutation"].map(self.data.parse_mut) + # ) # no longer need mutation annotation muts_df.reset_index(drop=True, inplace=True) @@ -1580,22 +1560,21 @@ def mut_param_heatmap( # melt conditions and stats cols, beta is already "tall" # note that we must rename conditions with "." in the # name to "_" to avoid altair errors - if mut_param == "beta": - muts_df_tall = muts_df.assign(condition=reference.replace(".", "_")) - else: - muts_df_tall = muts_df.melt( - id_vars=["wildtype", "site", "mutant"] + addtl_tooltip_stats, - value_vars=[c for c in muts_df.columns if c.startswith(mut_param)], - var_name="condition", - value_name=mut_param, - ) - muts_df_tall.condition.replace( - { - f"{mut_param}_{condition}": condition.replace(".", "_") - for condition in conditions - }, - inplace=True, - ) + # if mut_param == f"beta_{reference}": + # muts_df_tall = muts_df.assign(condition=reference.replace(".", "_")) + # else: + muts_df_tall = muts_df.melt( + id_vars=["wildtype", "site", "mutant"] + addtl_tooltip_stats, + value_vars=[c for c in muts_df.columns if c.startswith(mut_param)], + var_name="condition", + value_name=mut_param, + ) + muts_df_tall["condition"] = muts_df_tall.condition.replace( + { + f"{mut_param}_{condition}": condition.replace(".", "_") + for condition in conditions + }, + ) # add in condition colors, rename for altair condition_colors = { diff --git a/multidms/model_collection.py b/multidms/model_collection.py index 154ce0f..700433a 100644 --- a/multidms/model_collection.py +++ b/multidms/model_collection.py @@ -1,5 +1,9 @@ """ -Contains the ModelCollection class, which takes a collection of models +================ +model_collection +================ + +Contains the :class:`ModelCollection` class, which takes a collection of models and merges the results for comparison and visualization. """ @@ -13,10 +17,11 @@ import logging import multidms +from multidms.utils import explode_params_dict, my_concat import pandas as pd import jax -import jax.numpy as jnp + import numpy as onp import altair as alt @@ -42,53 +47,18 @@ class ModelCollectionFitError(Exception): pass -# https://github.com/microsoft/pylance-release/issues/5630 -def my_concat(dfs_list, axis=0): - """simple pd.concat wrapper for bug with vscode pylance""" # noqa - return pd.concat(dfs_list, axis=axis) - - -def _explode_params_dict(params_dict): - """ - Given a dictionary of model parameters, - of which any of the values can be a list of values, - compute all combinations of model parameter sets - and returns a list of dictionaries representing each - of the parameter sets. - """ - varNames = sorted(params_dict) - return [ - dict(zip(varNames, prod)) - for prod in it.product(*(params_dict[varName] for varName in varNames)) - ] - - -# everything below verbose could be a kwargs passed to fit() -# but it's nice to have a single function for verbosity? def fit_one_model( dataset, epistatic_model="Sigmoid", output_activation="Identity", - lock_beta_naught_at=None, # TODO experimental, remove - gamma_corrected=False, # TODO experimental, mark as such - alpha_d=False, # TODO, still not sure why this isn't the default - init_beta_naught=0.0, + # gamma_corrected=False, # GAMMA + init_theta_scale=6.5, + init_theta_bias=-3.5, n_hidden_units=5, lower_bound=None, PRNGKey=0, verbose=False, - # **kwargs, - scale_coeff_lasso_shift=2e-5, - tol=1e-4, - maxiter=20000, - acceleration=True, - maxls=15, - upper_bound_theta_ge_scale="infer", - huber_scale_huber=1, - scale_coeff_ridge_beta=0, - scale_coeff_ridge_shift=0, - scale_coeff_ridge_gamma=0, - scale_coeff_ridge_alpha_d=0, + **kwargs, ): """ Fit a multidms model to a dataset. This is a wrapper around the multidms @@ -101,49 +71,19 @@ def fit_one_model( The dataset to fit to. For bookkeeping and downstream analysis, the name of the dataset (Data.name) is saved in the fit attributes that are returned. - huber_scale_huber : float, optional - The scale of the huber loss function. The default is 1. - scale_coeff_lasso_shift : float, optional - The scale of the lasso penalty on the shift parameter. The default is 2e-5. - scale_coeff_ridge_beta : float, optional - The scale of the ridge penalty on the beta parameter. The default is 0. - scale_coeff_ridge_shift : float, optional - The scale of the ridge penalty on the shift parameter. The default is 0. - scale_coeff_ridge_gamma : float, optional - The scale of the ridge penalty on the gamma parameter. The default is 0. - scale_coeff_ridge_alpha_d : float, optional - The scale of the ridge penalty on the ch parameter. The default is 0. epistatic_model : str, optional The epistatic model to use. The default is "Identity". output_activation : str, optional The output activation function to use. The default is "Identity". - lock_beta_naught_at : float or None optional - The value to lock the beta_naught parameter to. If None, - the beta_naught parameter is free to vary. The default is None. - gamma_corrected : bool, optional - Whether to use the gamma corrected model. The default is True. - alpha_d : bool, optional - Whether to use the conditional c model. The default is False. - init_beta_naught : float, optional - The initial value of the beta_naught parameter. The default is 0.0. - Note that is lock_beta_naught is not None, then this value is irrelevant. - maxls : int - Maximum number of iterations to perform during line search. - tol : float, optional - The tolerance for the fit. The default is 1e-4. - maxiter : int, optional - The max number of iterations to take if the tolerance threshold is not met. - The default is 20000. - acceleration : bool, optional - Whether to use the FISTA acceleration. The default is True. This is only useful - when using a single step with many iterations. + init_theta_scale : float, optional + The scale to use for initializing the model parameters. The default is 6.5. + init_theta_bias : float, optional + The bias to use for initializing the model parameters. The default is -3.5. n_hidden_units : int, optional The number of hidden units to use in the neural network model. The default is 5. lower_bound : float, optional The lower bound for use with the softplus activation function. The default is None, but must be specified if using the softplus activation. - upper_bound_theta_ge_scale : float, optional - The upper bound for the theta_ge_scale parameter. The default is None. PRNGKey : int, optional The PRNGKey to use to initialize model parameters. The default is 0. verbose : bool, optional @@ -166,7 +106,12 @@ def fit_one_model( 3. "step_loss" which is a numpy array of the loss at the end of each training epoch. """ + # save the passed parameters for bookkeeping fit_attributes = locals().copy() + del fit_attributes["kwargs"] + for key, value in kwargs.items(): + fit_attributes[key] = value + biophysical_model = { "Identity": multidms.biophysical.identity_activation, "Sigmoid": multidms.biophysical.sigmoidal_global_epistasis, @@ -174,24 +119,18 @@ def fit_one_model( "Softplus": multidms.biophysical.softplus_activation, } - # should these all be kwargs? imodel = multidms.Model( dataset, epistatic_model=biophysical_model[epistatic_model], output_activation=biophysical_model[output_activation], - alpha_d=alpha_d, - gamma_corrected=gamma_corrected, - init_beta_naught=init_beta_naught, + init_theta_scale=init_theta_scale, + init_theta_bias=init_theta_bias, + # gamma_corrected=gamma_corrected, GAMMA n_hidden_units=n_hidden_units, lower_bound=lower_bound, PRNGKey=PRNGKey, ) - lock_params = {} - - if lock_beta_naught_at is not None: - lock_params["beta_naught"] = jnp.array([lock_beta_naught_at]) - del fit_attributes["dataset"] del fit_attributes["verbose"] @@ -202,56 +141,17 @@ def fit_one_model( print("running:") pprint.pprint(fit_attributes) - total_iterations = 0 - # for training_step in range(num_training_steps): start = time.time() imodel.fit( - warn_unconverged=False, - # **kwargs, - scale_coeff_lasso_shift=scale_coeff_lasso_shift, - maxiter=maxiter, - tol=tol, - acceleration=acceleration, - maxls=maxls, - huber_scale=huber_scale_huber, - lock_params=lock_params, - scale_coeff_ridge_shift=scale_coeff_ridge_shift, - scale_coeff_ridge_beta=scale_coeff_ridge_beta, - scale_coeff_ridge_gamma=scale_coeff_ridge_gamma, - scale_coeff_ridge_alpha_d=scale_coeff_ridge_alpha_d, - upper_bound_theta_ge_scale=upper_bound_theta_ge_scale, + warn_unconverged=verbose, + **kwargs, ) end = time.time() fit_attributes["fit_time"] = round(end - start) - col_order = [ - "model", - "dataset_name", - "epistatic_model", - "output_activation", - "gamma_corrected", - "alpha_d", - "n_hidden_units", - "lower_bound", - "PRNGKey", - "scale_coeff_lasso_shift", - "scale_coeff_ridge_beta", - "scale_coeff_ridge_shift", - "scale_coeff_ridge_gamma", - "scale_coeff_ridge_alpha_d", - "huber_scale_huber", - "init_beta_naught", - "lock_beta_naught_at", - "tol", - "maxiter", - "acceleration", - "maxls", - "fit_time", - ] - - return pd.Series(fit_attributes)[col_order] + return pd.Series(fit_attributes) def _fit_fun(params): @@ -312,7 +212,7 @@ def fit_models(params, n_threads=-1, failures="error"): if n_threads == -1: n_threads = multiprocessing.cpu_count() - exploded_params = _explode_params_dict(params) + exploded_params = explode_params_dict(params) # if __name__ == "__main__": # see https://pythonspeed.com/articles/python-multiprocessing/ for why we spawn with get_context("spawn").Pool(n_threads) as p: @@ -660,7 +560,10 @@ def convergence_trajectory_df( query=None, id_vars=("dataset_name", "scale_coeff_lasso_shift"), ): - """TODO""" + """ + Combine the converence trajectory dataframes of + all fits in the queried collection. + """ queried_fits = ( self.fit_models.query(query) if query is not None else self.fit_models ) @@ -681,7 +584,6 @@ def convergence_trajectory_df( ] ) - # TODO make altair chart return convergence_trajectory_data def mut_param_heatmap( @@ -762,7 +664,7 @@ def mut_param_heatmap( + [col for col in queried_fits.columns if "loss" in col] ) ) - print(shouldbe_uniform) + # print(shouldbe_uniform) groups_to_combine = queried_fits.groupby(shouldbe_uniform).ngroups if groups_to_combine > 1: warnings.warn( @@ -990,7 +892,7 @@ def shift_sparsity( self, x="scale_coeff_lasso_shift", width_scalar=100, - height_scalar=10, + height_scalar=100, return_data=False, **kwargs, ): @@ -1093,7 +995,7 @@ def mut_type(mut): def mut_param_dataset_correlation( self, x="scale_coeff_lasso_shift", - width_scalar=150, + width_scalar=200, height=200, return_data=False, r=2, diff --git a/multidms/utils.py b/multidms/utils.py new file mode 100644 index 0000000..12417ae --- /dev/null +++ b/multidms/utils.py @@ -0,0 +1,198 @@ +""" +========== +Utils +========== + +Helpful utility functions for the `multidms` package +""" + +import scipy as sp +import pandas as pd +import jax +import jax.numpy as jnp +import re +import itertools as it + + +def explode_params_dict(params_dict): + """ + Given a dictionary of model parameters, + of which any of the values can be a list of values, + compute all combinations of model parameter sets + and returns a list of dictionaries representing each + of the parameter sets. + """ + varNames = sorted(params_dict) + return [ + dict(zip(varNames, prod)) + for prod in it.product(*(params_dict[varName] for varName in varNames)) + ] + + +def my_concat(dfs_list, axis=0): + """ + simple pd.concat wrapper for bug with vscode pylance + See https://github.com/matsengrp/multidms/issues/156 for more details + """ # noqa + return pd.concat(dfs_list, axis=axis) + + +def split_sub(sub_string): + """ + A very simplistic function to split a mutations string into its constituent parts. + This function is only designed to work with simple mutation strings of the form + `A123B`, where `A` is the wildtype amino acid, `123` is the site, and `B` is the + mutant amino acid. + + .. note:: + It is favorable to use the `polyclonal.utils.MutationParser` class instead, + as that provides the ability to parse more complex mutation strings using allowed + alphabets. + + Parameters + ---------- + sub_string : str + A string containing a single mutation + + Returns + ------- + tuple + A tuple containing the wildtype amino acid, site, and mutant amino acid + """ + pattern = r"(?P[A-Z])(?P[\d\w]+)(?P[A-Z\*])" + match = re.search(pattern, sub_string) + assert match is not None, sub_string + return match.group("aawt"), str(match.group("site")), match.group("aamut") + + +def split_subs(subs_string, parser=split_sub): + """ + Given a mutation parsing function, split a string of mutations + into three lists containing the wildtype amino acids, sites, and + mutant amino acids. + + Parameters + ---------- + subs_string : str + A string containing multiple mutations + + parser : function + A function that can parse a single mutation string and returns a tuple + containing the wildtype amino acid, site, and mutant amino acid + + Returns + ------- + tuple + A tuple containing the wildtype amino acids, sites, and mutant amino acids + as lists + """ + wts, sites, muts = [], [], [] + for sub in subs_string.split(): + wt, site, mut = parser(sub) + wts.append(wt) + sites.append(site) + muts.append(mut) + return wts, sites, muts + + +def difference_matrix(n, ref_index=0): + """ + Given some number of conditions, return the difference matrix + for computing shifts between adjacent conditional beta parameters. + + Parameters + ---------- + n : int + The number of conditions + ref_index : int + The index of the reference condition + + Returns + ------- + jnp.ndarray + A difference matrix for computing shifts between + adjacent conditional beta parameters + """ + D = jnp.eye(n, n).at[:, ref_index].set(-1).at[ref_index].set(0) + + return D + + +def transform(params, bundle_idxs): + """ + Transforms the beta coefficient parameters of a `multidms` model to be + negative for the bundles specified in `bundle_idxs`, and the updated + beta0 parameters based on the new beta coefficients. + See `issue #156 `_ for more + on scaling parameters for training. + + Parameters + ---------- + params : dict + A dictionary containing the model parameters + "beta", and "beta0". + bundle_idxs : dict + A dictionary, keyed by condition + containing the bundle indices in the binarymap matrix. + + Returns + ------- + dict + A dictionary containing the transformed model parameters + "beta", and "beta0". + """ + params_transformed = { + key: val.copy() for key, val in params.items() if key not in ["beta", "beta0"] + } + params_transformed["beta"] = {} + params_transformed["beta0"] = {} + for d in params["beta"]: + params_transformed["beta"][d] = params["beta"][d].at[bundle_idxs[d]].mul(-1) + params_transformed["beta0"][d] = ( + params["beta0"][d] + params["beta"][d][bundle_idxs[d]].sum() + ) + return params_transformed + + +def rereference(X, bundle_idxs): + """ + Given a binary matrix X and bundle indices, re-reference the matrix + to flip the bit signs for the bundles specified in `bundle_idxs`. + This function is used to scale the data matrix for training a model. + See `issue #156 `_ for more + on scaling parameters for training. + + Parameters + ---------- + X : jax.experimental.sparse.BCOO + A binary matrix + bundle_idxs : jnp.ndarray + An boolean array indicating the bundle indices in the binarymap matrix. + + Returns + ------- + jax.experimental.sparse.BCOO + A re-referenced binary matrix + """ + if bundle_idxs.sum(): + X_scipy = sp.sparse.csr_matrix( + (X.data, (X.indices[:, 0], X.indices[:, 1])), shape=X.shape + ).tolil() + tmp = X_scipy[:, bundle_idxs].copy() + X_scipy[:, bundle_idxs] = 1 + X_scipy[:, bundle_idxs] -= tmp + X_scaled = jax.experimental.sparse.BCOO.from_scipy_sparse(X_scipy) + X_scaled = jax.experimental.sparse.BCOO( + (X_scaled.data.astype(jnp.int8), X_scaled.indices), shape=X.shape + ) + + assert ( + X[:, bundle_idxs].sum(0).todense() + + X_scaled[:, bundle_idxs].sum(0).todense() + == X.shape[0] + ).all() + + else: + X_scaled = X + + return X_scaled diff --git a/notebooks/fit_delta_BA1_example.ipynb b/notebooks/fit_delta_BA1_example.ipynb index f10e88b..ffa6874 100644 --- a/notebooks/fit_delta_BA1_example.ipynb +++ b/notebooks/fit_delta_BA1_example.ipynb @@ -37,13 +37,13 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "7ca0b6ca", "metadata": {}, "outputs": [], "source": [ - "%matplotlib inline\n", - "warnings.simplefilter('ignore')" + "# %matplotlib inline\n", + "# warnings.simplefilter('ignore')" ] }, { @@ -90,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "edbdcb12", "metadata": {}, "outputs": [ @@ -209,7 +209,7 @@ "[10000 rows x 3 columns]" ] }, - "execution_count": 4, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -230,7 +230,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "bceb25a0", "metadata": {}, "outputs": [ @@ -252,7 +252,7 @@ "Name: count, Length: 7637, dtype: int64" ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -279,7 +279,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "8bfc72bd", "metadata": { "scrolled": true @@ -295,7 +295,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a043385c1bc542259e87ec632d034aa7", + "model_id": "7b86638463a349bc8f9ebfa7209745ff", "version_major": 2, "version_minor": 0 }, @@ -316,7 +316,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "4dfcd1c11e374482aaacfa9fa8b5116e", + "model_id": "dc41e597b3204d6691f46fa1f1cb33e0", "version_major": 2, "version_minor": 0 }, @@ -338,7 +338,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "098402973c2d4a6195b4a108f0051d70", + "model_id": "b39263b1a2fb4daea8b9a02ec7e97937", "version_major": 2, "version_minor": 0 }, @@ -349,6 +349,14 @@ "metadata": {}, "output_type": "display_data" }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jgallowa/mambaforge/envs/multidms-dev/lib/python3.11/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n", + " self.pid = os.fork()\n" + ] + }, { "name": "stdout", "output_type": "stream", @@ -360,7 +368,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ff86a00c18af4ef9938f0fe50b42b677", + "model_id": "c26d9611fd4d419791efb2be83191afe", "version_major": 2, "version_minor": 0 }, @@ -371,6 +379,14 @@ "metadata": {}, "output_type": "display_data" }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jgallowa/mambaforge/envs/multidms-dev/lib/python3.11/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n", + " self.pid = os.fork()\n" + ] + }, { "name": "stdout", "output_type": "stream", @@ -384,7 +400,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "68d98557ad1e4c6c83af0f7defe794db", + "model_id": "51c42f505186418da5a708523328d32c", "version_major": 2, "version_minor": 0 }, @@ -394,6 +410,14 @@ }, "metadata": {}, "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jgallowa/mambaforge/envs/multidms-dev/lib/python3.11/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n", + " self.pid = os.fork()\n" + ] } ], "source": [ @@ -427,7 +451,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "dd493152", "metadata": {}, "outputs": [ @@ -495,7 +519,7 @@ "5 L L" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -515,7 +539,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "861db643", "metadata": {}, "outputs": [ @@ -583,7 +607,7 @@ "339 G D" ] }, - "execution_count": 8, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -603,7 +627,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "c4e343b8", "metadata": {}, "outputs": [ @@ -613,7 +637,7 @@ "('M1I', 'M1-', 'F2L', 'F2Y', 'V3F')" ] }, - "execution_count": 9, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -633,7 +657,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "id": "10448926", "metadata": {}, "outputs": [ @@ -673,8 +697,8 @@ " M\n", " 1\n", " I\n", - " 0.0\n", - " 1.0\n", + " 0\n", + " 1\n", " \n", " \n", " 1\n", @@ -682,8 +706,8 @@ " M\n", " 1\n", " -\n", - " 1.0\n", - " 0.0\n", + " 1\n", + " 0\n", " \n", " \n", " 2\n", @@ -691,8 +715,8 @@ " F\n", " 2\n", " L\n", - " 1.0\n", - " 1.0\n", + " 1\n", + " 1\n", " \n", " \n", " 3\n", @@ -700,8 +724,8 @@ " F\n", " 2\n", " Y\n", - " 1.0\n", - " 0.0\n", + " 1\n", + " 0\n", " \n", " \n", " 4\n", @@ -709,8 +733,8 @@ " V\n", " 3\n", " F\n", - " 1.0\n", - " 4.0\n", + " 1\n", + " 4\n", " \n", " \n", "\n", @@ -718,14 +742,14 @@ ], "text/plain": [ " mutation wts sites muts times_seen_Delta-2 times_seen_Omicron_BA1-2\n", - "0 M1I M 1 I 0.0 1.0\n", - "1 M1- M 1 - 1.0 0.0\n", - "2 F2L F 2 L 1.0 1.0\n", - "3 F2Y F 2 Y 1.0 0.0\n", - "4 V3F V 3 F 1.0 4.0" + "0 M1I M 1 I 0 1\n", + "1 M1- M 1 - 1 0\n", + "2 F2L F 2 L 1 1\n", + "3 F2Y F 2 Y 1 0\n", + "4 V3F V 3 F 1 4" ] }, - "execution_count": 10, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -745,7 +769,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "id": "c4e9d392", "metadata": {}, "outputs": [ @@ -831,7 +855,7 @@ "4 Delta-2 A1020C 1 0.50800 A1020C" ] }, - "execution_count": 11, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -851,7 +875,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "id": "652d1683", "metadata": {}, "outputs": [ @@ -914,7 +938,7 @@ "6831 R19T A67V T95I G156E G339D S373P N440K G446S G... " ] }, - "execution_count": 12, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -967,7 +991,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "id": "25e8e80a", "metadata": {}, "outputs": [], @@ -975,6 +999,28 @@ "model = multidms.Model(data)" ] }, + { + "cell_type": "code", + "execution_count": 13, + "id": "26bc7602", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model\n", + "Name: unnamed\n", + "Data: unnamed\n", + "Converged: False\n", + "\n" + ] + } + ], + "source": [ + "print(model)" + ] + }, { "cell_type": "markdown", "id": "42a25703", @@ -986,11 +1032,20 @@ { "cell_type": "code", "execution_count": 14, - "id": "f24570e7", + "id": "946bf04d", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jgallowa/Projects/multidms/multidms/model.py:1181: RuntimeWarning: Model training error did not reach the tolerance threshold. Final error: 0.021850742189881294, tolerance: 0.0001\n", + " warnings.warn(\n" + ] + } + ], "source": [ - "model.fit(maxiter=15000)" + "model.fit(maxiter=5000)" ] }, { @@ -998,14 +1053,78 @@ "id": "542e01a0", "metadata": {}, "source": [ - "This method uses the [jaxopt.ProximalGradient](https://jaxopt.github.io/stable/_autosummary/jaxopt.ProximalGradient.html) optimizer to fit the parameters (in place) to the data. Note that later we'll introduce the `model_collection` module interface for a more streamlined approach to creating and fitting one or more `Model` objects -- but the attributes and methods of individual `Model` objects are still be quite useful. \n", - "\n", - "For example, the `Model` object allows provides many of the same properties, like mutations and variants dataframes, but add additional features relevant to the parameters of this model. `Model.get_mutations_df` returns the associated data object's mutations_df as seen above, along with the $\\beta$ and $S_{m,h}$ parameter's associated with each mutation. " + "This method uses the [jaxopt.ProximalGradient](https://jaxopt.github.io/stable/_autosummary/jaxopt.ProximalGradient.html) optimizer to fit the parameters (in place) to the data. Note that later we'll introduce the `model_collection` module interface for a more streamlined approach to creating and fitting one or more `Model` objects -- but the attributes and methods of individual `Model` objects are still be quite useful.\n" + ] + }, + { + "cell_type": "markdown", + "id": "d85063b4", + "metadata": {}, + "source": [ + "Note the warning about convergence. The default convergence threshold is set to $10^{-4}$ which can sometimes take more playing with hyperparameters and more iterations to acheive. Toi suppress this warning, simply pass `warn_unconverged=True`. For our spike analysis manuscript, we needed to regularize model parameters and train the models for close to 30K iterations before convergence at this tolerence was acheived." + ] + }, + { + "cell_type": "markdown", + "id": "596d97c9", + "metadata": {}, + "source": [ + "`Model.convergence_trajectory_df` gives the models error metric (as reported by [jaxopt state object](https://jaxopt.github.io/stable/unconstrained.html#unpacking-results) -- and is useful to see how the model is changing through the fitting process) as well as the loss on the training data." ] }, { "cell_type": "code", "execution_count": 15, + "id": "56be955f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAHqCAYAAAAZLi26AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAADMqUlEQVR4nOzdd5xcdb0//teZPltmtiW72d0UktASIIFAQuiYSChSRbkIgqgoGq56w0Xl+r2igsCVKz+uuIpKtaIioNIEQkIoIb2SkF42yfYyZXf6nN8fZ86Zc86cKbs7s7Pl9XyYB7szZ858dnYS53Xen8/7I4iiKIKIiIiIiIiI8s5U7AEQERERERERjVUM3UREREREREQFwtBNREREREREVCAM3UREREREREQFwtBNREREREREVCAM3UREREREREQFwtBNREREREREVCAM3UREREREREQFYin2AEayeDyOY8eOoby8HIIgFHs4RERERERENEKIogifz4f6+nqYTOnr2QzdGRw7dgyTJ08u9jCIiIiIiIhohGpubkZjY2Pa+xm6MygvLwcgvYgul6vIoyEiIiIiIqKRwuv1YvLkyUpuTIehOwN5SrnL5WLoJiIiIiIiohTZliKzkRoRERERERFRgTB0ExERERERERUIQzcRERERERFRgTB0ExERERERERUIQ/co98G+Tnz+yTW47+UdxR4KERERERER6bB7+Sjn6Y/g3T2dCIRjxR4KERERERER6bDSPcqVO6wAAF8wWuSREBERERERkR5D9yhX7pAmK/iCkSKPhIiIiIiIiPQYuke5ZOhmpZuIiIiIiGikYege5eTp5f5wFPG4WOTREBERERERkRpD9ygnV7pFUQreRERERERENHIwdI9yDqsZNrP0a/RzijkREREREdGIMuZD98svv4wTTzwRxx9/PJ544oliD6cguK6biIiIiIhoZBrT+3RHo1EsW7YMK1asgNvtxrx583Dttdeiurq62EPLq3KHBV19YXYwJyIiIiIiGmHGdKV77dq1mD17NhoaGlBWVobLLrsMb7zxRrGHlXdlrHQTERERERGNSCM6dK9atQpXXnkl6uvrIQgCXnrppZRjmpqaMG3aNDgcDixYsABr165V7jt27BgaGhqU7xsaGnD06NHhGPqwKrdLHcy9rHQTERERERGNKCM6dPf19WHOnDloamoyvP/Pf/4zli1bhnvvvRcbN27EnDlzsGTJErS3tw/zSIuLa7qJiIiIiIhGphEdui+77DLcf//9uPbaaw3vf+SRR3D77bfjtttuw6xZs/D444+jpKQETz31FACgvr5eU9k+evQo6uvr0z5fKBSC1+vV/BkN5L26GbqJiIiIiIhGlhEdujMJh8PYsGEDFi9erNxmMpmwePFirF69GgAwf/58bN++HUePHoXf78drr72GJUuWpD3ngw8+CLfbrfyZPHlywX+OfEhWujm9nIiIiIiIaCQZtaG7s7MTsVgMtbW1mttra2vR2toKALBYLPjpT3+Kiy++GHPnzsVdd92VsXP5PffcA4/Ho/xpbm4u6M+QL65E6PaHWOkmIiIiIiIaScb0lmEAcNVVV+Gqq67K6Vi73Q673V7gEeUfp5cTERERERGNTKO20l1TUwOz2Yy2tjbN7W1tbairqyvSqIqD08uJiIiIiIhGplEbum02G+bNm4fly5crt8XjcSxfvhwLFy4c0rmbmpowa9YsnHXWWUMd5rCQ9+n2stJNREREREQ0oozo6eV+vx979+5Vvj9w4AA2b96MqqoqTJkyBcuWLcOtt96KM888E/Pnz8ejjz6Kvr4+3HbbbUN63qVLl2Lp0qXwer1wu91D/TEKjtPLiYiIiIiIRqYRHbrXr1+Piy++WPl+2bJlAIBbb70VzzzzDG644QZ0dHTg+9//PlpbWzF37ly8/vrrKc3VxjpOLyciIiIiIhqZRnTovuiiiyCKYsZj7rzzTtx5553DNKKRyaWEbla6iYiIiIiIRpJRu6abkuTp5f5QNOtFCiIiIiIiIho+DN0GRlsjNXl6eSwuIhCJFXk0REREREREJGPoNrB06VLs2LED69atK/ZQcuK0mmE2CQA4xZyIiIiIiGgkYegeAwRBYDM1IiIiIiKiEYihe4wo517dREREREREIw5D9xhRZude3URERERERCMNQ/cYwenlREREREREIw9Dt4HR1r0cACqcUqX7jY/aEI9z2zAiIiIiIqKRQBC5sXNaXq8XbrcbHo8HLper2MPJaOWudnzp2fWIxUXctGAKfnztqcUeEhERERER0ZiVa15kpXuMuOjEiXjks3NgEoA/rDmM9/d2FntIRERERERE4x5D9xhy9dwG3LJwGgDgodc+5jRzIiIiIiKiImPoHmPu/MRMlNrM2HbUg1e2tRR7OEREREREROMaQ/cYU1Nmx1cumAEAePr9A0UeDRERERER0fjG0D0G3XDWZADApuZedPhCRR4NERERERHR+MXQbWA0bhmmVud2YE6jG6IILN/ZVuzhEBERERERjVsM3QaWLl2KHTt2YN26dcUeyqBdMrsOAPDGDoZuIiIiIiKiYmHoHqM+OasWAPDe3k70haJFHg0REREREdH4xNA9Rh0/sQzTqksQjsbxHvfsJiIiIiIiKgqG7jFKEAScM7MGALDxUE+RR0NERERERDQ+MXSPYadPrgAAbDrcW9RxEBERERERjVcM3WPY6VMqAABbj/YiGosXdzBERERERETjEEO3gdG+ZZhsek0Zyh0WBCNxfNzqK/ZwiIiIiIiIxh2GbgNjYcswADCZBMxNTDHf3Nxb1LEQERERERGNRwzdYxxDNxERERERUfEwdI9x8rruTYfZwZyIiIiIiGi4MXSPcXMaKwAA+zr64AlEijsYIiIiIiKicYahe4yrLrNjSlUJAGALp5gTERERERENK4bucUCeYs513URERERERMOLoXsckJupcV03ERERERHR8GLoHgdOn1IJQKp0i6JY5NEQERERERGNHwzd48DJk8phM5vQ0x/B4e7+Yg+HiIiIiIho3GDoNtDU1IRZs2bhrLPOKvZQ8sJuMWNWvQsAsOlwb3EHQ0RERERENI4wdBtYunQpduzYgXXr1hV7KHnD/bqJiIiIiIiGH0P3OCE3U9t61FPcgRAREREREY0jDN3jxGmNFQCAHce8iMTixR0MERERERHROMHQPU5MrSpBucOCUDSO3W2+Yg+HiIiIiIhoXGDoHidMJgGnNboBANuOcIo5ERERERHRcGDoHkdObagAAGxh6CYiIiIiIhoWDN3jiFLpPtpb3IEQERERERGNEwzd44gcuj9u8SEYiRV5NERERERERGMfQ/c40lDhRFWpDdG4iJ0t3mIPh4iIiIiIaMxj6B5HBEHA6Yn9utcf7CnuYIiIiIiIiMYBhu5xZuGMagDAB/s6izwSIiIiIiKisY+h20BTUxNmzZqFs846q9hDybuzp0uhe+2BbkRi8SKPhoiIiIiIaGxj6DawdOlS7NixA+vWrSv2UPJu1iQX3E4r+sIxbDvKrcOIiIiIiIgKiaF7nDGZBCxMVLtX7+sq8miIiIiIiIjGNobucUhe183QTUREREREVFgM3ePQOYnQve5gNwJh7tdNRERERERUKAzd49DMiWVoqHAiFI2zizkREREREVEBMXSPQ4IgYNHJEwEAyz9uL/JoiIiIiIiIxi6G7nHqEydJofvtne0QRbHIoyEiIiIiIhqbGLrHqbOnV6PEZkarN4iPjnmLPRwiIiIiIqIxiaF7nHJYzThvZg0A4G1OMSciIiIiIiqIQYXuZ599Fq+88ory/be//W1UVFTgnHPOwaFDh/I2OCosZV33zrYij4SIiIiIiGhsGlTofuCBB+B0OgEAq1evRlNTE37yk5+gpqYG//Ef/5HXAVLhXHyiFLq3HPGg3Rcs8miIiIiIiIjGnkGF7ubmZsycORMA8NJLL+HTn/40vvKVr+DBBx/Eu+++m9cBUuFMdDkwp9ENAFj5cUeRR0NERERERDT2DCp0l5WVoaurCwDwxhtv4JOf/CQAwOFwIBAI5G90VHCfOKkWAPAWp5gTERERERHl3aBC9yc/+Ul8+ctfxpe//GXs3r0bl19+OQDgo48+wrRp0/I5PioweV33e3s7EYzEijwaIiIiIiKisWVQobupqQkLFy5ER0cH/va3v6G6uhoAsGHDBtx44415HSAV1ux6F+pcDvSHY/hgX2exh0NERERERDSmCKIoisUexEjl9Xrhdrvh8XjgcrmKPZyCuffv2/Hs6kO47owGPPLZucUeDhERERER0YiXa14cVKX79ddfx3vvvad839TUhLlz5+Jzn/scenp6BnPKEaWpqQmzZs3CWWedVeyhDItPzakHALzxURunmBMREREREeXRoEL33XffDa/XCwDYtm0b7rrrLlx++eU4cOAAli1bltcBFsPSpUuxY8cOrFu3rthDGRbzplSizuWAPxTFO7vZxZyIiIiIiChfBhW6Dxw4gFmzZgEA/va3v+FTn/oUHnjgATQ1NeG1117L6wCp8EwmAVecNgkA8PLWliKPhoiIiIiIaOwYVOi22Wzo7+8HALz11lu45JJLAABVVVVKBZxGl08lQvfynW0IhDnFnIiIiIiIKB8GFbrPO+88LFu2DPfddx/Wrl2LK664AgCwe/duNDY25nWANDzmTq5AY6UT/eEY3v64vdjDISIiIiIiGhMGFbp//vOfw2Kx4Pnnn8cvf/lLNDQ0AABee+01XHrppXkdIA0PQVBPMT9W5NEQERERERGNDdwyLIPxsmWYbPtRDz712HuwW0zY8N+fRJndUuwhERERERERjUi55sVBp6pYLIaXXnoJO3fuBADMnj0bV111Fcxm82BPSUU2u96FadUlONjVj+U723D13IZiD4mIiIiIiGhUG9T08r179+Lkk0/GLbfcghdeeAEvvPACbr75ZsyePRv79u3L9xhpmAiCgCsTe3a/uOlokUdDREREREQ0+g0qdH/jG9/AjBkz0NzcjI0bN2Ljxo04fPgwjjvuOHzjG9/I9xhpGF13htQIb9XuDrR5g0UeDRERERER0eg2qND9zjvv4Cc/+QmqqqqU26qrq/HQQw/hnXfeydvgaPgdV1OKM6dWIi6y2k1ERERERDRUgwrddrsdPp8v5Xa/3w+bzTbkQVFxXT9PqnY/v+EI2GePiIiIiIho8AYVuj/1qU/hK1/5CtasWQNRFCGKIj788EPccccduOqqq/I9Rhpml582CQ6rCXvb/dhyxFPs4RAREREREY1agwrdP/vZzzBjxgwsXLgQDocDDocD55xzDmbOnIlHH300z0Ok4eZyWHHp7DoAwPMbmos8GiIiIiIiotFrSPt07927V9ky7OSTT8bMmTPzNrCRYLzt06323p5O3PzkGrgcFqz93mI4rNwKjoiIiIiISJb3fbqXLVuW8f4VK1YoXz/yyCO5npZGqIUzqlHvduCYJ4i3drbhU6fVF3tIREREREREo07OoXvTpk05HScIwqAHQyOH2STgujMa8fMVe/HX9UcYuomIiIiIiAYh59CtrmTT+HD9PCl0r9rTgebufkyuKin2kIiIiIiIiEaVQTVSo/FhWk0pzptZA1EE/rj2cLGHQ0RERERENOowdFNGN589BQDwl3XNCEVjRR4NERERERHR6MLQTRktPrkWtS47uvrCeH17a7GHQ0RERERENKowdFNGFrMJn5s/FQDwxLsHMIQd5oiIiIiIiMYdhm7K6uazp8BuMWHbUQ9W7+8q9nCIiIiIiIhGjXERuq+99lpUVlbi+uuvL/ZQRqXqMjs+c2YjAOA3q/YXeTRERERERESjx7gI3d/85jfx29/+ttjDGNW+fN50CAKwYlcHdrf5ij0cIiIiIiKiUWFchO6LLroI5eXlxR7GqDatphRLZtUBAH7NajcREREREVFOih66V61ahSuvvBL19fUQBAEvvfRSyjFNTU2YNm0aHA4HFixYgLVr1w7/QAlfuXA6AODvm4+i1RMs8miIiIiIiIhGvqKH7r6+PsyZMwdNTU2G9//5z3/GsmXLcO+992Ljxo2YM2cOlixZgvb2duWYuXPn4pRTTkn5c+zYseH6McaFM6ZU4qxplYjERDz9wYFiD4eIiIiIiGjEsxR7AJdddhkuu+yytPc/8sgjuP3223HbbbcBAB5//HG88soreOqpp/Dd734XALB58+a8jCUUCiEUCinfe73evJx3LPnKBTOw7uB6/H71IdxxwQxUltqKPSQiIiIiIqIRq+iV7kzC4TA2bNiAxYsXK7eZTCYsXrwYq1evzvvzPfjgg3C73cqfyZMn5/05RrvFJ0/E7HoX+sIx/Ppdru0mIiIiIiLKZESH7s7OTsRiMdTW1mpur62tRWtra87nWbx4MT7zmc/g1VdfRWNjY9rAfs8998Dj8Sh/mpubhzT+sUgQBPzH4hMAAM9+cBCd/lCWRxAREREREY1fRZ9ePhzeeuutnI6z2+2w2+0FHs3ot+jkiZjT6MaWIx78/O29+MFVs4s9JCIiIiIiohFpRFe6a2pqYDab0dbWprm9ra0NdXV1RRoVCYKA71x6EgDg9x8ewoHOviKPiIiIiIiIaGQa0aHbZrNh3rx5WL58uXJbPB7H8uXLsXDhwiKOjM6ZWYNPnDQR0biIh17bWezhEBERERERjUhFD91+vx+bN29WOpAfOHAAmzdvxuHDhwEAy5Ytw29+8xs8++yz2LlzJ772ta+hr69P6WZeCE1NTZg1axbOOuusgj3HWHDPZSfBJAD/+qgN7+3pLPZwiIiIiIiIRhxBFEWxmANYuXIlLr744pTbb731VjzzzDMAgJ///Od4+OGH0drairlz5+JnP/sZFixYUPCxeb1euN1ueDweuFyugj/faPSDf3yEZz44iOk1pXjtW+fDbjEXe0hEREREREQFl2teLHroHskYurPzBiP4xP++g05/CHd98gT8+6Ljiz0kIiIiIiKigss1LxZ9ejmNbi6HFf/9qZMBAI+9vRcft3qLPCIiIiIiIqKRg6GbhuyqOfVYfPJEhGNx3PWXLQhH48UeEhERERER0YjA0G2AjdQGRhAEPHDdqagoseKjY1787xu7ij0kIiIiIiKiEYFrujPgmu6BeX17K+74/QYAwOM3n4FLT5lU5BEREREREREVBtd007C79JQ63H7+cQCA//zrVuxs4fpuIiIiIiIa3xi6Ka++felJOHt6FfyhKG57eh1aPIFiD4mIiIiIiKhoGLopr6xmE35185k4fmIZWr1B3PTEGrR5g8UeFhERERERUVEwdFPeuUusePq2s9BQ4cT+jj78268/RHN3f7GHRURERERENOwYug2we/nQNVaW4LmvnI2GCicOdPbh2l+8jw2Heoo9LCIiIiIiomHF7uUZsHv50LV4AvjSM+uxo8ULm8WEh68/DVfPbSj2sIiIiIiIiIaE3ctpRJjkduKvdyzE4pNrEY7G8c3nNuOBV3ciHI0Xe2hEREREREQFx9BNBVdqt+BXn5+Hr14wHQDw61X7ce0v3sfedl+RR0ZERERERFRYDN00LMwmAfdcfjJ+9fl5qCyx4qNjXlzxs/fwzPsHEItzhQMREREREY1NDN00rJbMrsPr37oA5x9fg1A0jh/8cweu+vl7bLJGRERERERjEkO3AXYvL6xalwPP3jYf9109Gy6HBR8d8+LTv/wAd/91C1o8gWIPj4iIiIiIKG/YvTwDdi8vvE5/CP/z2sf464YjAAC7xYRbz5mGr104A5WltiKPjoiIiIiIyFiueZGhOwOG7uGz4VAPHnptJ9YdlKaZl9ktuP386fjS+cehzG4p8uiIiIiIiIi0GLrzgKF7eImiiJW7OvCTf+3CzhYvAKCq1IbbzpmGWxZOg7vEWuQREhERERERSRi684ChuzjicRGvbGvBI2/uxoHOPgBS5fums6fgS+cdh4nljiKPkIiIiIiIxjuG7jxg6C6uaCyOV7a14Bcr9mFXm7Snt81iwvXzGnHLwqk4qY6/EyIiIiIiKg6G7jxg6B4Z4nERb3/cjl+s3IuNh3uV28+aVombz56KS0+pg91iLt4AiYiIiIho3GHozgOG7pFFFEWsOdCNZz84iDd2tCEWl9661aU2XD+vEVfNrcesSS4IglDkkRIRERER0VjH0D0ETU1NaGpqQiwWw+7duxm6R6A2bxDPrW3Gn9YeRqs3qNw+vaYUn5pTjytPm4Tja8uLOEIiIiIiIhrLGLrzgJXukS8ai+Otne34++ajePvjdoSiceW+mRPLcMHxE3D+8TVYML0KJTZuPUZERERERPnB0J0HDN2jiz8UxVs72vDPLcewak8HIrHkW9tmNmHe1EosnFGNM6ZUYs5kN8od3IKMiIiIiIgGh6E7Dxi6Ry9PfwTv7+vEu3s6sWp3B472BjT3CwJwwsRynDG1AqdPqcQZUyowvaYMJhPXgxMRERERUXYM3XnA0D02iKKIg139eHdPB9Yf7MHGwz040hNIOa7MbsHsehdObXDj1EY3Tm1wY1p1KYM4ERERERGlYOjOA4busavdF8Smw73YeLgHmw71YuvRXgQj8ZTjyu0WzG6Qg3gFTm1wY2pVCYM4EREREdE4x9CdBwzd40c0FsfeDj+2HfFg21Hpz45jXk1jNlm5w4JZk1w4qa4cJ9a5cGJdGU6oLecacSIiIiKicYShOw8Yuse3aCyOPe1+KYQnwviOFi/CBkEcABoqnDihtgwzJpRhWk0pjqspxbSaUkxyOVgZJyIiIiIaYxi684Chm/QisTj2tPmxs8WLXW0+7GqV/qj3CtezW0yYWl2CadVSEJ9SXYLGyhJMrnSivsIJh9U8jD8BERERERHlQ655kRsXG2hqakJTUxNisVixh0IjjNVswqx6F2bVa/9SefojUghv8+FARx8OdvXhYGcfDnf3IxSNY3ebH7vb/IbnnFhux+SqEjRWOhN/SjC5Uvq+vsIJm8U0HD8aEREREREVACvdGbDSTUMVjcVxtDeAA51SCD/Y1Y/m7n409/TjSE8A/eHMF3YEAahzOZQwXl/hwCS3E5Pcyf9WlFghCJy+TkREREQ0nDi9PA8YuqmQRFFET38Ezd1SAD+SCOJyID/S02/YUV3PYTUpAbzO7UC92yn9t8KBOpf0dSWDORERERFRXnF6OdEIJwgCqkptqCq1Yc7kipT7RVFEpz+sCeMtvUG0eIJo8QTQ6gmiqy+MYCSOA519ONDZl/a5rGYBE8rsmOByYGK5PfHHgQny1y7p+5oyGyxmTmcnIiIiIsoXhm6iEUoQBEwot2NCuR2nT6k0PCYYiaHNmwziLZ6gJpi3eILo7gsjEhNxzBPEMU/6hm/ScwLVpTZMUAdyJZg7NGHdaWMDOCIiIiKibBi6iUYxh9WMqdWlmFpdmvaYcDSODn8IHb4Q2r1BtPtCaPeF0OELot0bSnwfRKc/jFhcqq53+sPY2ZL5uUtsZlSV2lBdZkd1omJfXWpDdZkNVaV21dc2VJcypBMRERHR+MTQTTTG2SwmNFQ40VDhzHhcPC6iuz+cCOLBRDBPBvUOXzKgByNx9Idj6A8HcKQnkNM4nFYzqstsyYCeCOsVJTZUllhRUWJNfC197y6xwm5hUCciIiKi0Y2hm4gAACaTgJoyO2rK7JiF9I0gRFGELxRFtz+Mrr4wuvvC6PKH0nwt/TcciyMQiSUaxOUW0gGpml5ZYoPbaUVlqTUZ0J02VJRYUVliU4V16XuX0wqziU3jiIiIiGhkYOgmogERBAEuhxUuhxXTatJPa5eJogh/KIouVUjv7guhMxHIe/rD6O2PoDfx357+MDyBCOIilGr60d7cg7ogAC6HVaqWO61wyX8c8vcW1deJ/zosyvdWNpIjIiIiojxi6CaighIEAeUOK8pzDOmANNXdF4xKgTwQSQRzOZRLAb1HH9T7I/CFohBFwBOIwBOIDGq8TqtZCeduTVi3otRuRqndgjK7BaU2i/K9cpvdgrLE7ewCT0REREQAQzcRjUAmkwB3Yl33QERicfT2R+AJSKHc0x+BNxiBNxCBJxCFNyiFcW8ilHuDUXgT3/tCUQBAIBJDIBJDq3doP4PdYlKCeInNnAzldos2vMt/bGblWKfVDKfNjBKbRfnaaTXDZmGQJyIiIhptGLqJaMywmk3KNmsDFYuL8AUj8BqGc+l2fyiKvlAUfeEo/KGY9HVIdXsohnAsDgAIReMIRaUp9fliMQlKAC+xmeG0WeC0mlBis8CRuK3EZjb42gKnzQSnNRHqNecwo8RqgcNmgs1sgiBwPTwRERFRPjF0G2hqakJTUxNisVixh0JEw8RsElBRInVTH4pwNK4E8f5wTBXI1aE9ebs6sPeFowiEpUp7fziGYDiG/kgMsbgIAIgmpt37gtF8/MgpTAJgt5hht5rgSPPfbPc7LCbYrWY4EsfK/7WaTTCbBFjNQuK/ie9NJljMAiwmARb9MSYTTGyKR0RERKOcIIqiWOxBjFRerxdutxsejwcuV/puzkREhSKKIiIxEYFwDP0RKZT3J4K5/HUwEdL7w1Hla/X9ya+jCETiCISjSrAPhGOIxkfu/w2YBMCSCObasC7AbE6GdrPJpAnrZpMAizl5vMUk3Sf/kb43aW636O4zm6A5xmIWYBIEzfdmkwlmQfW4xAUE5TZz6vNon8sEk0n6GfXjtJgEzjwgIiIawXLNi6x0ExGNYIIgwGYRYLOY4MbA1rjnKhKT9l0PRWMIReIIRWMIZvpvJIZgNI5QJI5g4jH6/4ZU3wcjUrCPxkREY3Hp63jq10bZPy4C4Vgc4XE68Ui+6CCHcJP+4oBZFfBVFxuMLw6oLiKYVQFfEJSLGvI5jC5EJJ/bpHxvEgCTIJ1DkL82ab82CdL72CwIMJlUXwuJx5vSfC0fY0Li/NLt5sQxgv5r5ZzSYwy/ToyFiIhoODF0ExGNc1azCW6nCShQqM9VXA7g8XgypMfjiMZExOIiIjHd7ZmOUYf6mIiYKCKW+D4Wl78Xle+jcRFxMXFsXHWc6v5YYmyxODTHGB8r3R+PixmOiyfGnH6mgXzRAeP0okMhqAN6SnA3acO5OvzLFxL0/5WPAaAJ+fLjBaSew2QCBKSeQ3mMwfPKYzJ6jHSbwVgTP6+Q+BpC8nmV+1TfQz7O4D75PGnvS3wv3a96biTHrX4O5ViD80D9OOW5Mz2H9hzQfJ8Ys+48hs+heS305838HEavW8prlcNYjV9P7X36181wrPrXM5fnUJ8z5fXnxSqioWDoJiKiEcFkEmAzCbBh/HVpj8sXAuRwnriYoNwWM7o4kAzuqRcHpOAfi0M5ZqAXB6KxxHPJj48lL1jI98VFEbG4tAwiLoqIiaqv4yLiie/lr+XHxOOqr0Xp55e/jsXFxDmAmKj6OnGMqP9aTH6dC1EEoqIIYOQuqyAaqTIGe6SGd+0FH/3FC+0FEe0FiNTzKM+fy3PozpEcv/GFHP0FoZx/xmzPofs+7c+Y5mKQ+nWXXyv18yhfp3yROJ/qseq7BYPjNM+jucaS/jzasRmcJ8149cdlGu+kCie+dN5xKY8dbRi6iYiIisxkEmCCAKu52CMZveRwbhjsVV/HEgFdvjCg/lq5SJB4jIjk/fK5ReXxyXOKyn3a/8ZV3+vHl/Ux8s8U150H2u/l++Xb5Yse8jGQ/qeMW/o6+bPJr518O5C8L3mb/DOk3idC9xzK7cnvoX6c/BjNcarnSHMe6MatHwtSxiY/C1THiJpxJ8+T5jlSfgb92JLnUL8PU+7P9jPm8hyJ+1N/P9rfXaGpX0vVrcPz5DQuzWl0M3QTERERjQTSWnHAjNRqCtF4ob24khreAaMLAqrgbnhRRHue5MUBg/Pk8hzqseiPHchY9ReA0owz03lSLwhleQ7dOdTnVr7O9BwG59FcDDK4iJL8GYwvbqgvlqXelttx2vPldh71uYzGq75RTL0p5/FOcjtSBzkKMXQTEREREY0B8vTtxHfFHAoRqYy/hXNEREREREREw4Shm4iIiIiIiKhAGLqJiIiIiIiICoShm4iIiIiIiKhAGLqJiIiIiIiICoTdyzOQW+Z7vd4ij4SIiIiIiIhGEjknptvSTcbQnYHP5wMATJ48ucgjISIiIiIiopHI5/PB7XanvV8Qs8XycSwej+PYsWMoLy+HIIzcvQ69Xi8mT56M5uZmuFyuYg+HiO9JGnH4nqSRhu9JGmn4nqSRZjS8J0VRhM/nQ319PUym9Cu3WenOwGQyobGxsdjDyJnL5Rqxb0gan/iepJGG70kaafiepJGG70kaaUb6ezJThVvGRmpEREREREREBcLQTURERERERFQgDN1jgN1ux7333gu73V7soRAB4HuSRh6+J2mk4XuSRhq+J2mkGUvvSTZSIyIiIiIiIioQVrqJiIiIiIiICoShm4iIiIiIiKhAGLqJiIiIiIiICoShm4iIiIiIiKhAGLpHuaamJkybNg0OhwMLFizA2rVriz0kGiNWrVqFK6+8EvX19RAEAS+99JLmflEU8f3vfx+TJk2C0+nE4sWLsWfPHs0x3d3duOmmm+ByuVBRUYEvfelL8Pv9mmO2bt2K888/Hw6HA5MnT8ZPfvKTQv9oNAo9+OCDOOuss1BeXo6JEyfimmuuwa5duzTHBINBLF26FNXV1SgrK8OnP/1ptLW1aY45fPgwrrjiCpSUlGDixIm4++67EY1GNcesXLkSZ5xxBux2O2bOnIlnnnmm0D8ejUK//OUvcdppp8HlcsHlcmHhwoV47bXXlPv5fqRie+ihhyAIAr71rW8pt/F9ScPpBz/4AQRB0Pw56aSTlPvH1ftRpFHrueeeE202m/jUU0+JH330kXj77beLFRUVYltbW7GHRmPAq6++Kn7ve98TX3jhBRGA+OKLL2ruf+ihh0S32y2+9NJL4pYtW8SrrrpKPO6448RAIKAcc+mll4pz5swRP/zwQ/Hdd98VZ86cKd54443K/R6PR6ytrRVvuukmcfv27eKf/vQn0el0ir/61a+G68ekUWLJkiXi008/LW7fvl3cvHmzePnll4tTpkwR/X6/cswdd9whTp48WVy+fLm4fv168eyzzxbPOecc5f5oNCqecsop4uLFi8VNmzaJr776qlhTUyPec889yjH79+8XS0pKxGXLlok7duwQH3vsMdFsNouvv/76sP68NPL94x//EF955RVx9+7d4q5du8T/+q//Eq1Wq7h9+3ZRFPl+pOJau3atOG3aNPG0004Tv/nNbyq3831Jw+nee+8VZ8+eLba0tCh/Ojo6lPvH0/uRoXsUmz9/vrh06VLl+1gsJtbX14sPPvhgEUdFY5E+dMfjcbGurk58+OGHldt6e3tFu90u/ulPfxJFURR37NghAhDXrVunHPPaa6+JgiCIR48eFUVRFH/xi1+IlZWVYigUUo75zne+I5544okF/olotGtvbxcBiO+8844oitL7z2q1in/961+VY3bu3CkCEFevXi2KonQhyWQyia2trcoxv/zlL0WXy6W8B7/97W+Ls2fP1jzXDTfcIC5ZsqTQPxKNAZWVleITTzzB9yMVlc/nE48//njxzTffFC+88EIldPN9ScPt3nvvFefMmWN433h7P3J6+SgVDoexYcMGLF68WLnNZDJh8eLFWL16dRFHRuPBgQMH0Nraqnn/ud1uLFiwQHn/rV69GhUVFTjzzDOVYxYvXgyTyYQ1a9Yox1xwwQWw2WzKMUuWLMGuXbvQ09MzTD8NjUYejwcAUFVVBQDYsGEDIpGI5j150kknYcqUKZr35Kmnnora2lrlmCVLlsDr9eKjjz5SjlGfQz6G/65SJrFYDM899xz6+vqwcOFCvh+pqJYuXYorrrgi5b3D9yUVw549e1BfX4/p06fjpptuwuHDhwGMv/cjQ/co1dnZiVgspnkTAkBtbS1aW1uLNCoaL+T3WKb3X2trKyZOnKi532KxoKqqSnOM0TnUz0GkF4/H8a1vfQvnnnsuTjnlFADS+8Vms6GiokJzrP49me39lu4Yr9eLQCBQiB+HRrFt27ahrKwMdrsdd9xxB1588UXMmjWL70cqmueeew4bN27Egw8+mHIf35c03BYsWIBnnnkGr7/+On75y1/iwIEDOP/88+Hz+cbd+9FS7AEQERENxNKlS7F9+3a89957xR4KjXMnnngiNm/eDI/Hg+effx633nor3nnnnWIPi8ap5uZmfPOb38Sbb74Jh8NR7OEQ4bLLLlO+Pu2007BgwQJMnToVf/nLX+B0Oos4suHHSvcoVVNTA7PZnNLhr62tDXV1dUUaFY0X8nss0/uvrq4O7e3tmvuj0Si6u7s1xxidQ/0cRGp33nknXn75ZaxYsQKNjY3K7XV1dQiHw+jt7dUcr39PZnu/pTvG5XKNuw8IlJ3NZsPMmTMxb948PPjgg5gzZw7+7//+j+9HKooNGzagvb0dZ5xxBiwWCywWC9555x387Gc/g8ViQW1tLd+XVFQVFRU44YQTsHfv3nH37yRD9yhls9kwb948LF++XLktHo9j+fLlWLhwYRFHRuPBcccdh7q6Os37z+v1Ys2aNcr7b+HChejt7cWGDRuUY95++23E43EsWLBAOWbVqlWIRCLKMW+++SZOPPFEVFZWDtNPQ6OBKIq488478eKLL+Ltt9/Gcccdp7l/3rx5sFqtmvfkrl27cPjwYc17ctu2bZqLQW+++SZcLhdmzZqlHKM+h3wM/12lXMTjcYRCIb4fqSgWLVqEbdu2YfPmzcqfM888EzfddJPyNd+XVEx+vx/79u3DpEmTxt+/k8Xu5EaD99xzz4l2u1185plnxB07dohf+cpXxIqKCk2HP6LB8vl84qZNm8RNmzaJAMRHHnlE3LRpk3jo0CFRFKUtwyoqKsS///3v4tatW8Wrr77acMuw008/XVyzZo343nvviccff7xmy7De3l6xtrZW/PznPy9u375dfO6558SSkhJuGUYpvva1r4lut1tcuXKlZuuR/v5+5Zg77rhDnDJlivj222+L69evFxcuXCguXLhQuV/eeuSSSy4RN2/eLL7++uvihAkTDLceufvuu8WdO3eKTU1NI3LrESq+7373u+I777wjHjhwQNy6dav43e9+VxQEQXzjjTdEUeT7kUYGdfdyUeT7kobXXXfdJa5cuVI8cOCA+P7774uLFy8Wa2pqxPb2dlEUx9f7kaF7lHvsscfEKVOmiDabTZw/f7744YcfFntINEasWLFCBJDy59ZbbxVFUdo27L//+7/F2tpa0W63i4sWLRJ37dqlOUdXV5d44403imVlZaLL5RJvu+020efzaY7ZsmWLeN5554l2u11saGgQH3rooeH6EWkUMXovAhCffvpp5ZhAICB+/etfFysrK8WSkhLx2muvFVtaWjTnOXjwoHjZZZeJTqdTrKmpEe+66y4xEolojlmxYoU4d+5c0WazidOnT9c8B5Hsi1/8ojh16lTRZrOJEyZMEBctWqQEblHk+5FGBn3o5vuShtMNN9wgTpo0SbTZbGJDQ4N4ww03iHv37lXuH0/vR0EURbE4NXYiIiIiIiKisY1ruomIiIiIiIgKhKGbiIiIiIiIqEAYuomIiIiIiIgKhKGbiIiIiIiIqEAYuomIiIiIiIgKhKGbiIiIiIiIqEAYuomIiIiIiIgKhKGbiIiIiIiIqEAYuomIiEjjC1/4Aq655ppiD4OIiGhMYOgmIiIiIiIiKhCGbiIionHq+eefx6mnngqn04nq6mosXrwYd999N5599ln8/e9/hyAIEAQBK1euBAA0Nzfjs5/9LCoqKlBVVYWrr74aBw8eVM4nV8h/+MMfYsKECXC5XLjjjjsQDoeL8wMSERGNAJZiD4CIiIiGX0tLC2688Ub85Cc/wbXXXgufz4d3330Xt9xyCw4fPgyv14unn34aAFBVVYVIJIIlS5Zg4cKFePfdd2GxWHD//ffj0ksvxdatW2Gz2QAAy5cvh8PhwMqVK3Hw4EHcdtttqK6uxo9//ONi/rhERERFw9BNREQ0DrW0tCAajeK6667D1KlTAQCnnnoqAMDpdCIUCqGurk45/ve//z3i8TieeOIJCIIAAHj66adRUVGBlStX4pJLLgEA2Gw2PPXUUygpKcHs2bPxox/9CHfffTfuu+8+mEycYEdEROMP/9+PiIhoHJozZw4WLVqEU089FZ/5zGfwm9/8Bj09PWmP37JlC/bu3Yvy8nKUlZWhrKwMVVVVCAaD2Ldvn+a8JSUlyvcLFy6E3+9Hc3NzQX8eIiKikYqVbiIionHIbDbjzTffxAcffIA33ngDjz32GL73ve9hzZo1hsf7/X7MmzcPf/jDH1LumzBhQqGHS0RENGoxdBMREY1TgiDg3HPPxbnnnovvf//7mDp1Kl588UXYbDbEYjHNsWeccQb+/Oc/Y+LEiXC5XGnPuWXLFgQCATidTgDAhx9+iLKyMkyePLmgPwsREdFIxenlRERE49CaNWvwwAMPYP369Th8+DBeeOEFdHR04OSTT8a0adOwdetW7Nq1C52dnYhEIrjppptQU1ODq6++Gu+++y4OHDiAlStX4hvf+AaOHDminDccDuNLX/oSduzYgVdffRX33nsv7rzzTq7nJiKicYuVbiIionHI5XJh1apVePTRR+H1ejF16lT89Kc/xWWXXYYzzzwTK1euxJlnngm/348VK1bgoosuwqpVq/Cd73wH1113HXw+HxoaGrBo0SJN5XvRokU4/vjjccEFFyAUCuHGG2/ED37wg+L9oEREREUmiKIoFnsQRERENPp94QtfQG9vL1566aViD4WIiGjE4FwvIiIiIiIiogJh6CYiIiIiIiIqEE4vJyIiIiIiIioQVrqJiIiIiIiICoShm4iIiIiIiKhAGLqJiIiIiIiICoShm4iIiIiIiKhAGLqJiIiIiIiICoShm4iIiIiIiKhAGLqJiIiIiIiICoShm4iIiIiIiKhAGLqJiIiIiIiICoShm4iIiIiIiKhAGLqJiIiIiIiICoShm4iIiIiIiKhAGLqJiIiIiIiICoShm4iIiIiIiKhAGLqJiIiIiIiICoShm4iIiIiIiKhALMUeQKG9/PLLuOuuuxCPx/Gd73wHX/7yl3N+bDwex7Fjx1BeXg5BEAo4SiIiIiIiIhpNRFGEz+dDfX09TKb09WxBFEVxGMc1rKLRKGbNmoUVK1bA7XZj3rx5+OCDD1BdXZ3T448cOYLJkycXeJREREREREQ0WjU3N6OxsTHt/WO60r127VrMnj0bDQ0NAIDLLrsMb7zxBm688cacHl9eXg5AehFdLlfBxklERERERESji9frxeTJk5XcmM6IDt2rVq3Cww8/jA0bNqClpQUvvvgirrnmGs0xTU1NePjhh9Ha2oo5c+bgsccew/z58wEAx44dUwI3ADQ0NODo0aM5P788pdzlcjF0ExERERERUYpsS5FHdCO1vr4+zJkzB01NTYb3//nPf8ayZctw7733YuPGjZgzZw6WLFmC9vb2YR4pERERERERUaoRHbovu+wy3H///bj22msN73/kkUdw++2347bbbsOsWbPw+OOPo6SkBE899RQAoL6+XlPZPnr0KOrr69M+XygUgtfr1fwhIiIiIiIiGqwRHbozCYfD2LBhAxYvXqzcZjKZsHjxYqxevRoAMH/+fGzfvh1Hjx6F3+/Ha6+9hiVLlqQ954MPPgi32638YRM1IiIiIiIiGopRG7o7OzsRi8VQW1urub22thatra0AAIvFgp/+9Ke4+OKLMXfuXNx1110ZO5ffc8898Hg8yp/m5uaC/gxEREREREQ0to3oRmr5cNVVV+Gqq67K6Vi73Q673V7gEY1M8biIb/9tK6ZPKMXXL5pZ7OEQERERERGNCaO20l1TUwOz2Yy2tjbN7W1tbairqyvSqEav/Z1+PL/hCH6xYl+xh0JERERERDRmjNrQbbPZMG/ePCxfvly5LR6PY/ny5Vi4cOGQzt3U1IRZs2bhrLPOGuowR42e/ggAIBiJFXkkREREREREY8eInl7u9/uxd+9e5fsDBw5g8+bNqKqqwpQpU7Bs2TLceuutOPPMMzF//nw8+uij6Ovrw2233Tak5126dCmWLl0Kr9cLt9s91B9jVOhNhO5oXEQ0FofFPGqvxxAREREREY0YIzp0r1+/HhdffLHy/bJlywAAt956K5555hnccMMN6OjowPe//320trZi7ty5eP3111Oaq1F2nkBE+TrM0E1ERERERJQXIzp0X3TRRRBFMeMxd955J+68885hGtHY1dsfVr4OReIosRVxMERERERERGMEy5kGxuOabq+q0h2Kxos4EiIiIiIiorGDodvA0qVLsWPHDqxbt67YQxk2vZrQzWZqRERERERE+cDQTQB0a7rTVLo/2NeJJ97dn3XKPxEREREREUlG9JpuGj5y93Ig/fTy//fSduzv6MM5M2owq941XEMjIiIiIiIatVjpJgDaSne66eWeRDDv9IeGZUxERERERESjHUO3gfHYSE0TuiPGlW65Au4LRodlTERERERERKMdQ7eBcdlITb1lWJrp5cGIVAH3BSOG9xMREREREZEWQzchHhezTi+PxuKIxqUGaqx0ExERERER5Yahm+APRxFXNSQ3qnSrb/Oy0k1ERERERJQThm5SGqTJjNZ0q0M3K91ERERERES5YegmzdRywHh6ufo2VrqJiIiIiIhyw9BtYKx3L9eH6tTQnVrpDkZY6SYiIiIiIhoohm4DY7l7+QOv7sQZP3oTH+zrVG7r1U8vN1zTnQzq7F5ORERERESUG4bucebXq/ajLxzD536zRqlwp1S6I6nTy9WVbm+AlW4iIiIiIqJcMHSPMy6HRfn6B//4CKIoojcQ1hxjWOlWBXFfiJVuIiIiIiKiXFiyH0JjhSiKmor1i5uOYk6jO7c13exeTkRERERENGCsdI8jvlAU4ZgUnu/65AkAgPte2Yl3dnUAAGwW6e2QtdIdjEIUxZRj0onHcz+WiIiIiIhoLGHoHke6/dI08hKbGXd+Yiaun9eIWFzEx60+AMDEcjuAdFuGJYN4LC4iYLDu28jvPzyE0374BjYc6hnq8ImIiIiIiEYdhm4DY3XLsK4+KXRXldogCAJ+fO0pOGNKhXJ/rcsBIN2WYdqQnWsztXd2d8AfimIjQzcREREREY1DDN0GxuqWYd2J0F1dJlW07RYzHv/8PExyS2H7hNpyAEAoYrRlmPa2XLcNk9eLG1XPiYiIiIiIxjo2UhtHuvwhAEB1qU25bWK5A//89/Owu9WHVm8Qf1p72DAgp1S6c2ym5umXQ3dqkCciIiIiIhrrWOkeR9TTy9Vqyuw4Z2YN7BYzgDSN1IZc6WboJiIiIiKi8YehexxRppfrQrfMnmP3ciD3bcPkPcDDDN1ERERERDQOMXSPI91pKt0yuzURuiMxvLunA4+8sUuZVq4P4t4cKt3BSEzZF5xruomIiIiIaDzimu5xpFNe051opKYnTy8PR+O49+8fYX9nH1bu7sCLXz83ZU13LpVubyAZzI2asxEREREREY11DN3jyECmlx/tDQAAth7x4H/f2DWoNd296tDN6eVERERERDQOcXq5gbG6T3eu08uDkRjMJkG5/a/rm5XQ7Egck0ul26MJ3ZxeTkRERERE4w9Dt4Gxsk/3tiMe/OT1j9EfjkIUxbTdy2Xy9PLeQASxuKjc7glElOnlE8qlqem5hO7efla6iYiIiIhofOP08jHsjt9vwNHeAPZ39OHhz5ymdBCvLss8vVwduAEgEhOVqnVNmR3N3QHNeu10PFzTTURERERE4xwr3WOYvC779Y9a0emXqtxOqxklNuNrLXLoltWU2SHPMm/3SU3YJpQNpNIdVr7m9HIiIiIiIhqPGLrHsFpXskv53zcfBZB+ajkA2K1mzfcVJVaUO6wAgA45dCeml/f0hyGK2oq4npeN1IiIiIiIaJxj6B7Dgqop3U+/fxBA+qnlAGAza98OFU4rXE6pKi5PFT+hthwAsKfdj+///aOUqehq6u7lYYZuIiIiIiIahxi6x6h4XIRXta2XHJozVbqtZgFCsmk53E4ryu1WzTEn1Jbj3itnQRCA3314CM9vaE57Pg8r3URERERENM4xdI9RvlAU8uzvey47CefMqMZxNaW4fl5j2scIgqBZ1+0uSVa6ZXarCbedexxuOXsqAGBXqz/t+bTdy7mmm4iIiIiIxh92Lx+j5PXUdosJX71wBr564YycHme3mJVp6W6nNaVhmiOxrVit2wEA8AXTdzFn93IiIiIiIhrvWOkeo+TA63Zasxyppa50VzhtKHekVroBKA3WfMEo4nERT7y7H+sOdhuOAeD0ciIiIiIiGp8YuseoQYduq2p6udMCl0P7eEeiw7krEcZ9oQg2HO7B/a/sxE2/WYMP9nWmjAEAwrE44hmarhEREREREY1FDN0GmpqaMGvWLJx11lnFHsqgyYG3omSgle7ktmHuEqsSrpP3y5Vu6XZvIIo2bxCAFKy/+tsN2HHMC1EUNaFbvp+IiIiIiGg8Yeg2sHTpUuzYsQPr1q0r9lAGLV/Ty126x8v3u5Tp5RFNwzRfKIpbn16LnS2+lO3EuK6biIiIiIjGG4buMUoO3frQnI06dLuc1pQ13fL0cvWabvm5lsyuxUl15ejwhXBN0/vK+UyJbciK3cH8kTd349an1uLdPR0QRU51JyIiIiKiwmPoHqMGX+lOTi+vKLFq1nSbBMCSSNDK9PJgBL39YQDAlKoSPPvF+WiocCpTycvsFuWcxW6m9vR7B/DO7g58/sm1+NHLO4o6FiIiIiIiGh8YuseYv6xrxh/WHMpTIzWrUtEGpCq3IEihW66gR2Ii2rwhAEBFiQ21Lgd+c8uZymO6+sLKOYsdun2h5PZnq3Z3FHEkREREREQ0XjB0jyHhaBzf/ttWfO/F7fi4xQtg4KHbZtaGbpczOb1cPfW81GZWpo039/QDSAbxWfUu/OKmM2A1C7h+XqPyuGJOL9d3Tvfq9h8nIiIiIiIqBEv2Q2i0CKpC7ZYjHgCDqXRLU8FLbWZYzaaUSrdMEASU2S3wBqNo7g4AACpUz3X5qZOwcHo13E4rLvrflQCKW+nWd0736jqrExERERERFQIr3WNIWBVq5c7hg+1eLj9OvWWYutINJJupdfrl6eXa56ostcFkEpKV7iJ2Lw9GtFX2UDRe9MZuREREREQ09jF0jyFhg0ryoEN3iQ0A0la6gdTO6OmeK7mmu3ghV66yC4L0B5A6rxMRERERERUSQ/cYYjR9e7Ddy92Jtdw2i0kJ4qmVbu3qhAqnLeM5+0IxPP3+Aexq9Q1oTPkgV9mdVjPKbInO65xiTkREREREBcY13WNIXirdiaq0OkC7nFZ0+EKa7cQA7dTzTM8lh/XXP2rFP7ccAwC8tPRczJ1cMaCxDYVcZXdYzXBazfCFomymRkREREREBcdK9xhiFLr1U8CzKbVJwbqyNBm65Yq2ejsx6fbkuQUhtfItk0P3oa4+5bbPP7kGzd39AxrbUAQTlW67xaSM0xdkpZuIiIiIiAqLoXsMCce0a6btFlPKOuxsrjm9ATecORlfOGeacpsrEa4zVbrdTitM8h5iOrZE6G5P7OcNSOupV+5qH9DYhkKudNstJuVChDfASjcRERERERUWp5ePIfru4AOdWg4AjZUl+J/rT9PcJleGHRkq3ZmeSw7rcpdz2XBO75bXu9stZuUigncEV7qDkRiO9PSjzu1EmZ1/TYmIiIiIRit+mh9DQrGhh24jcmVYX+lWTyevyBi6pbAeTWxjJvMGI2jzBnH381vxyZMn4uazp0IQjKvlQyVvGeawmpQK/UhupHbDrz/EluZeANLvsb7CiYYKB84/fgJuVc1CICIiIiKikY2h20BTUxOampoQi42ufZz1a7r1+2YPlitNpVu9XlzeYsyIfi14rcuONm8I3kAUb+1sw6rdHVi1uwPbj3rxw6tnD3hKfC40lW7nyK9072r1Kl97AhF4AhHsbPHirZ3tuPzUSZhQbi/i6IiIiIiIKFcM3QaWLl2KpUuXwuv1wu12F3s4OdOH7pkTy/Ny3qpEU7UyXaO0ct2a7nT0FfLJlSVo84bgC0bQ258Mvn9e34zNzb149N/m4uRJrnwMXaGs6VZVukfqPt2iKCqN31b850WIxOI42hPAN57bBF8wiu6+8IBCtyiKuPOPm7CjxYs6lwOT3A7MqnfhtnOPgznNOnwiIiIiIsoPhu4xRA7d5x9fg3uvnI0pVSV5Oe9NC6YiHI3j5gVTNber13TnMr1cNrmqBOsP9cAXjMKTmOJ9Ym05uvpC2NXmw9U/fx/fvvREfPHc49I2ZxuoUMSg0j1Cp5eHVcsEqstscDmsOKG2HDVldviC0QFX6Fu9QbyyrQUAcKBT6iD/wqajmDXJhXNm1uR0jkA4hnd2d8BqFjCr3oVJbueAxkBERERENF6xe/kYop5CPXNimdI1fKjqK5z43hWzMFkX4gdf6ZYCmzcYgSdR6b5yziS8/q0LsPjkiQjH4rj/lZ249pcfYP3B7rz8DPKabqnSLU8vH5mV7pBqxoL6gsVg16LLVXOn1YxHb5iLGRNKAQDtvlCmh2k8+d5+3PH7DfjSs+tx4cMr0eXP/NgVu9rxwKs78ehbu3Gwsy/jsYB0MSAaS93yjoiIiIhotGPoHkPCqm2xhoNLXenOsH5cv6a7MRHefcEoegNhAFJorymz4ze3nIkHrj0VpTYztjT34vrHV+Nrv9+QU3DLJHlBIrlP90itdKu70NvMqtCduLDhGeC45an1pXYzrjm9ASfWScsOBlIxP9iV3FM9HI3jUIY91kVRxNI/bMSvV+3Ho2/twX0v78h47hUft+Pi/12Jn/xrV8bjjvT04xt/2oSlf9yIx5bvQVzXmE/9/Ac7+3Cws0+52EJEREREVCycXj6GyNOS81Xhzka/T3c6KdPLK6XQ7U00CAOSjdgEQcDnFkzB4lkT8f+9uRt/XteM17a34o0dbbj29AbcceH0Qa1VH02N1NR7iqu7uSsV+oGGbtXU+sGeRx/0Mz02HIujP5wMu63eYMZz7+vwAwB2t/kyHvfCxqP4x5ZjAIBX0IJzZtZg3tTKlON+u/oQ7v3HRwCACeV2rPjPiwy3Xdt6pBd/WnsYd11yImrK2JiOiIiIiAqDle4xRF7Tra6OFtJA9+kGALNJQH2FAwASa7qjho+fWO7Ag9edhle/eT4uOnECYnERz284gsWPrMLnn1yDtz9uS1vpNCIHWYdqevlIbaQWjCSr8mrJiwUDG7d6av1gz6MP2ZkeG9I19MtWmZePz3YRoC+sfc50U9w/VnV+7/CF0s6SePK9A/jT2ma8nAjyes3d/bj2F+/jla0taccUi4sQxdzfh0REREQ0/jB0jyFKNdc6PL9Wh9UES6LRWUWGLcNsunXJcsAORGJKcEoX2k+qc+GZ2+bjxa+fg0tm1UIQgHf3dOKLz6zHJ366Ek+/f0AJ1JkENY3URvj0cuUCgXYt/GDHra7yA4NbGy6HbGdiTJkeq54en8vzhBIXBbKGc/150wT/XJ+/LyQ9vqff+P5Vezqw6XAv/rK+2fh5ojEs+ulK3Pr0upT7evvDeOLd/egYwLp5IiIiIhqbGLrHkOGudAuCgFqXVLWuS/zXiLpiW1Fi00z1lZt5Zep+DgCnT6nEr285E6vuvhi3n38cyh0WHOzqxw//uQNNK/ZlHat6yrZc6e4Lx0Zk8650F0+SDeAGG7q1le6BrA2Xg+vkqmQTvHT066h9oWjGWQlKpTtL5V1/cSVdmA7qj0szVvl5070O8oWadI9v6Q3iYFc/3tvTkfLz/XHtYdz/yk488d7+lMf9+JUduKbpfc3rtOFQD17blr6iTkRERESjF0P3GCKHiOFa0w0Aj33udDx24+mYUp1+ezJ16HY7rbCYTSi1aau4maanq02uKsH3rpiFD+9ZhM/MawQAHOnuRzASw+efXIOv/2EDtjT3pjxOWddsNWn2Gx+JU8z1a7Blya3OBjbmkK7B3mDCuxxwGxPr8TMFdvl96EhcNBBFwB/OPh09e0U8t2nruR4nh970oTyWcVzyuONi6tR3ef/5dm9qpfvFTUexubkXO1uS0+CX/mEjvvaHjWjxBAyfSy0cjeOPaw7jcFd/yu1ERERENPIwdI8hw91IDQDOmFKJK+fUZzzGrpomLYdr9XpwIBkoc1VqtyhNtLzBCHa0ePHunk68uq0VVze9j5ue+BBrDyS3GwvKQdBihtVsQkki9I/EZmr6kCyTp4UPuHu5csEhMb1cmaaeW3iPxUX4ElOxG+Xt3jI8Vh6/y2FVfgZPminc6uND0XjGbuNyyJVnSmSrYMvSjTUZ9jNPU/ekuV89Vv3vRJ4ybxTY5fPKF3xicVFpNmcU0vXe/rgd//XiNjzw6k7ltk2He3DKD/6FX65Mzvro9Ifwg398pAn3slhcHPD7iIiIiIgGZ8DpLBKJYNGiRdizZ08hxkNDEI4aV0iLTTu9XArXcvADpP2+zSYh5XHZlDuSlV851DmsJphNAt7f24Ubfr0azYmtrUL6ZmIjuJla9kZqQ5te7h7geXyq45TO8xkeq54en8uY1ZXpTL8POZxPKJc6jacP09JxE+Xj0oXzLNPHk9Pes4d7/VgyPVae/i6HXr/qZ87ld9LdJ22zp+4Kv+FQD8LROFbv71Ju+/vmY3jmg4P49arUKe7ffG4Tzrr/LRzpSVbLl+9swyNv7EqZKj+QhoVERERElGrAodtqtWLr1q2FGAsNUTGml+dCP70cyL3zeSZKxTYYUcLKvKmVeOfui1DrskMUgaO90nTdlGZiI7iZWrLSrZtePsg13XJFVm7MNtAtw+RA6bSaUV1my/pY9fT4ZNO29GFavQY7l2nrE8qyhGn5OCWcD3b6uHR/OE0FXr3GXD8WZeq67ueOxUVEYqLmMerH5lJ9Nhq3vB5efVt3Xyjx33DKOT465kU4Fseu1uQ2bfe/shM/e3svth31KLd987lNuPB/VyhN54iIiIho4AaVzm6++WY8+eST+R4LDVE48WF85IXuZHiUG6blusd3JupqtRxWXA4rGitLMMktT4OWbldvGaZ+7MicXq5dEy1zD3pNt3EjNW8wmtN2V/Jr5HJaVK9b9oq03WLKqaqurnTn0qBtgitLmI7oQne6LudZ1pIHs4xLM2799PI0le6wQXVcHbRz+d0anVt+fqMAbzz21PXs8iwDdUh/Z3cHmrsD2NvuzzouIiIiIjJmyX5Iqmg0iqeeegpvvfUW5s2bh9LSUs39jzzySF4GRwOjTC8fpu7luVJ34XYZVLrlKecDlWwsFlGml8shT75PDhJBXXOy8hwqsMWir8rL5Oq8LxhBPC7ClOOU/HSN1GJxEX3hmKabvBE5vLmd1uTrmqEiq54en0undO007dwr3WkbqcnT0LMel7lruqaSHYhiYnmGcQeNp5enrPU2qI5rK9Y5VLrlafEB6aKJIAjJ0K16P8tfG64rN1jPrlTQVWPINgWfiIiIiLIbVOjevn07zjjjDADA7t27NfcJwsDX5lJ+yI3Uhmuf7lzptwwDkqEXGEqlOxFCQ1F094c151JCdVCudBtXe3++Yi/8oSiuP7NRCaPFpl9/LpPHJ3fL1jejS3s+XYh3WE2wmgVEYiK8gUjW0O1VzSKQg3/mEJ2czp7LVHZtEM1QQddVsNOt/w7qK91Zupf7Q1FEY3FYdBertKHaKLhmaKSWuK8/HEMkFoc1cW6jCwxGFetMlGnvsThC0TgcVrPhVHX5a6NGcEZVfv1toiiqprKPvItTRERERKPFoEL3ihUr8j0OyoPh3qc7V+qKrb4Srb5toNSh82hPQHNel0M7FVtf7b16bj2W72zH4e5+/OjlHXj4X7twxWmTcM3cBiycUT2oxm75or9AIHNYzbBZTAhH4/AEIrmH7oj2YowgCHA5rOjqC8MbjKAezoyPT04vt2qm5ctV1kzjT667z75lGJBbmJ+Y41rtrI3UVM/rD0WVC0LK/ZHM4wpmml6uaw5XVWpLe07PQCvduuDusJqVc8jrzx1Ws2GoT45d28xNFEXl3w/5dxWJiZB7qLHSTURERDR4Q05nR44cwZEjR/IxFhqikdpIzWbQvVxb6balPCbX8zoTzcGa9aHbqat0R+R10tLxnzipFh/+1yLcd80pOKG2DIFIDM9vOIKbn1yDhQ8uxw//+RE+2NuJSGz49z5WKt0GXej1FxNyITcqcxhc/MjlPOrp5fLjIjFREzrV1JV1tzOHSneG8Gp03okuBwBphkPMoLO2/jijnzEai2sea3SMdnp55kq3PpSmmzIfNKjqG00Jz8Sowq49hzbM6xvBRWNxROPaZm5G481UyR9OHx3z4C/rm3PqP0BEREQ0Eg0qncXjcfzoRz+C2+3G1KlTMXXqVFRUVOC+++5DPD78IYUk4REauo26l7vy0L0cSIZreesj/fn1AUI9ZbvMbsHnz56Kf33rAvz1joX43IIpcDutaPeF8PT7B/G5J9bgjB+9iaV/2Ig/rDmE/R3+Yfngn66RGpB6MSGn8+kq3QBQnkMYlsmBzuWwoMRmVmYBpN+KK/laD3x6efbQXVOWvEjjM5z2rZ1ebhQY9Xt5ZzvGqFKfacswdcg1WiMtPSa10p1LuDVq8GY0rdybZiuycCx13EYV+FzX2hfad/+2Dd9+fqumqzoRERHRaDKo6eXf+9738OSTT+Khhx7CueeeCwB477338IMf/ADBYBA//vGP8zpIys1I3qfbZjYhHIsr02zzsaYbkMJ1mzekrO/VT1/XV7qNXhtBEHDWtCqcNa0KP7hyNlbuasebO9qwYlc7Ov1hvLKtBa9sawEA1LrsOHt6Nc6eXo2F06sxtbok730M0jVSU/98AwlB+qn1QHI9fC7hXT29XJqabkFPfwTeQAS1iWqy8fhz26dbO007w9ZiiSBbbrfCaTUjEInBG9BOC1dXsOVGaoFIDOFoXHMxSh+6M3X4lsaVpXt5hkq3OkgbNlIzCMyZGIV9bXBPbaCmbgRnNG6jcWVb0z5c5G7qbd7QgB/b0xdGfySGhorMSyiIiIiICmlQofvZZ5/FE088gauuukq57bTTTkNDQwO+/vWvj7jQfe2112LlypVYtGgRnn/++WIPp2BG6vRyQRBw/zWnwBuMoCYRhNRrugfbvRzQhndAXenWdifPVD1Ws1lMuGR2HS6ZXYd4XMSWI714Z3cHPtzfhY2He9HmDeHvm4/h75uPAQDqXA4snFGNs6dXYeH0Gkyucg45hBuFZFkuW3alni81xOfSVVymnl4uP7anP5K+0m04vTz7FmNAbpVuu1VaKx6IxDKG3ZpEpRuQKuLVZXbVcdp9tzN1+E43rlwaqUnnVncITw3M2nCcS/dy7esVicXRH9beFozEMgR/o9BtVP02/hmGW7at3TL59OMfoNUTxJr/WqT0QNjT5kMoGscpDe68jpOIiIgonUGF7u7ubpx00kkpt5900kno7u4e8qDy7Zvf/Ca++MUv4tlnny32UApKCd0jrJEaAHz2rMma7/OxTzegDe/qc6krrLG4mOzsPoBZACaTgNOnVOL0KZUApErrpsO9WL2/Cx/u78Lmw71o9Qbx4qajeHHTUQBAvduBs2ckK+GTq0oG/DMFDaaDy1yDqnSnNmYbyNpwdfdy9X/TbsUVSe6Jnu1Y9fjUz6WnrmDbLSZlhoP+ePW0bqfVjHK7Bb5QFN5gVBu6IzlUujNMH8827nSBXb9OXBRFXSO13Pfpls+hf25vIPWCSLoxJKeSj9xKt9FWZrkQRREHO/sQF4EWTxDlDivicRE3/PpD9Iej2PD/PonSLJ37iYiIiPJhUJ845syZg5///Of42c9+prn95z//OebMmZOXgeXTRRddhJUrVxZ7GAUXTnw4HWmVbiN5W9Ot6+Ath3n5dl8wqky7B4yrx7lyWM1YOKMaC2dUAwAC4Rg2He5JhvDmXhzzBPHCxqN4YaMUwhsqnIlKuFQNb6jIXglPVrqNGqll37Ir5XwGW5ANZG24HATlxyiPTRPY1ZXuXJ4nl9Ad0vwOVRX0NJVuq1mA2STA5bTCF4qmvF7BlEq3QahOsy5bOYfqfv32Zemaw6lvl7f80qy9HsCWYYD0PtAHdSmIp96WHHfqxQSjTuzBLNPrh0u6Pc+zicZV3dcTj/WHo8p09U5/aMCh+1fv7EOty4FrTm8Y0OOIiIhofBtU6P7JT36CK664Am+99RYWLlwIAFi9ejWam5vx6quvDuhcq1atwsMPP4wNGzagpaUFL774Iq655hrNMU1NTXj44YfR2tqKOXPm4LHHHsP8+fMHM/QxLVnNHfmhuzzPjdSS3+umlwcjmpCSz9fGaTPjnJk1OGdmDQCgPxzFxkO9WL2/Ex/u78aW5l4c7Q3g+Q1H8PwGqcN/TZkdpzW6cUqDG6cm/tS67Jognlx/nqHSPYCqX1CeWm/YvTz36eXyc6cLvDL19PhsjdRSuoinqfSGdBdO0k2PD+l+VmW/9gxbehmdR/+cWaefq+5X728NaF+n1LCvrVSHVFt+paNv8JZS6Q6mXmRQv67qsfmCEcTj+vFql2QAxeteHo+rtjIb4BR3o/Hr17kPRJs3iAdf+xglNjOunluf914ORERENHYNKnRfeOGF2L17N5qamvDxxx8DAK677jp8/etfR319/YDO1dfXhzlz5uCLX/wirrvuupT7//znP2PZsmV4/PHHsWDBAjz66KNYsmQJdu3ahYkTJwIA5s6di2g09QPUG2+8MeDxjGZhg2nEI5XbaYXZJEAURVSWDm7LMEBb6S61mWFNTK1XT8MOJCp2FpMASwGn3pfYLDjv+Bqcd7wUwvtCUWw4lKyEbz3iQac/hLc/bsfbH7crjyu3WzB9QilmTCjDjQumqNaf52fLMMNKtyP38J5uennaqrRqerwc0PvCMURj8ZTXP6WhWZa9t21mE0wmIWXNvv44+WdNd5Eip0ZqAwjd8vZlZpOg2d9aP0ajae2pATmSOXTrqtIpjzeaXp5mTXdcBPrC0ZRzShcOMndvHw6aTusDnF5uNFNhoHuiq8mzGfrD0nr5TL8jvWgsjh+9vAPnzKjGpadMGtDzEhER0eg34NAdiURw6aWX4vHHH89Lw7TLLrsMl112Wdr7H3nkEdx+++247bbbAACPP/44XnnlFTz11FP47ne/CwDYvHnzkMcBAKFQCKFQskOu1+vNy3mHQzQWVz7oj4bp5U6bGQ9cewriorR112Cp13SrK+ZyMIyLye7Hw30xotRuwQUnTMAFJ0wAIE1H39HixfajHmw76sH2ox7sbvPBF4piyxEPthzxYGerD2V2c9rxyj/j3g4/PtjbiTq3A5PcTjht6QOAUVf7gTRSk8NJ6nr57NPL1Y3uvMGo0r1ef6zMkwh8+iqivvqfNkzrutSnu0iRWyO11Oqv9rm05/AFI6gosaWcO10TM+m+qEFATnYaN6Kvohut3zZa550ctz74RzXjisZFKViOgOnlue7hbiSouWiSuif6QKv3+vX4Awndm5t78dvVh/De3k6GbiIionFowGnHarVi69athRhLinA4jA0bNuCee+5RbjOZTFi8eDFWr16d9+d78MEH8cMf/jDv5x0O6g/NoyF0A8ANZ00Z8jnUlW51AHdYTbCapapjh0+6kGIfwIfkQnDazJg3tRLzplYqt4WiMRzq6scHezvxg3/uQKc/BItJ2obLqJGaHFq3NPfic0+sUW53O62Y5HZgktuBKVUlWHRyrRL2jRupZV6XrR6fvN43Zep+lqq03WKCxWxCqc2MvnAM3kAkJXQHdcE1GhcRiMRQYtP+0xTUVbDTTY/X/6zudNPQDYKnWiwuIhJTTXvPYa9vefuyTFV0fSDv9IeSr6/DIk0Xz1KB1a/JTl2/bTTlPP0YPP2R1IsQwYjm58hl2nsh5NrZ3vCxBhcNNJXuAYdubdV9osF2een0JbrL9yQuAA6HLc29cDutmFZTilA0hp6+COrcuY+ZiIiI8mdQ6ezmm2/Gk08+me+xpOjs7EQsFkNtba3m9traWrS2tuZ8nsWLF+Mzn/kMXn31VTQ2NqYN7Pfccw88Ho/yp7m5eUjjH07qZmEjsXt5oajXdKtDt7SftPS9HLodI/BihN1ixgm15Vg8S3qPewMRZGqkdtGJE/Cl847DeTNrMGNCKUoSFW5PIIKPW31YsasDz64+hNt/u155T+inXAPJ16rDH8Kmwz1o7u5PCcDSeKRAJwjSNHj1Y9NVCuVQKAe0TOvQ5SBTZrfAYhI0z6k5Ll0FW9/ATNdMMF0jt2zT2o1CqCiKWY/Jdm592G/u7gcgvb4NlSWGY9HTr1WWfw9Ws6DcltpczXjbMnncRhcQ9Lfpm8UNh2wd5HN+7CD3RFdT//3wDHAs8mO9wWjK+6gQuvvCuP7xD3Dzk9KFuaV/2IRzHlqOQ119BX9uIiIiSjWoeb3RaBRPPfUU3nrrLcybNw+lpaWa+x955JG8DC5f3nrrrZyOs9vtsNvt2Q8cgeS1j+YCr1seaTJ1QXc5rejqC6PDPzIq3ZnIwTQUjSvhwmh6ucNqxn9/apbyvSiK8IWiaPUE0eIJ4mhPAP/14rZEV2xpX/SgLrACQGWJVHHu8IVw7S8+UG4vt1swodyOmjI7JpTblfBaZrfAlAjF6arHMv0+426nFS2eYJptt5Lbi9ksJnT3heENplbk9BVsOUyndCVX1pPrp5cbh2p5NkS2SngkJiIYiWum8Qf11XJ5+62IPoynD7xHegIApNe3Isu0ff3YpWOT08sbKpw42NWvmV5eU2ZDpz+sbeamH18gYrjWPOW4YAQTyof338dglg7ymWTfE30IIX6QVfJYYup+obcqa/EEEImJONITQCwuYmeLF3ER2N3mx9Tq0uwnICIiorwa1P/zb9++HWeccQYAYPfu3Zr78tnRtaamBmazGW1tbZrb29raUFdXl7fnGQvkquZ4qnID6dd0A8lp0Mr08hFY6ZaV2SwQBEAUpSnHgHEjNT25ou9yWHFCrbQQ+MFXd0p7Uwek0K0OtrJp1SX48nnHYd2hHnT6QujwhxCOxuELReELRbG/U1sRm6Da41oOsh/s68JJ//0aKpw2VJRYUVliw5fPPy4ZkOVmZonj/775KPZ3+mEzm2A1mzCpwqFMI7dbzLCaBXT3hXGwsw/1FU6U2szKvycpFewsYdqRsvZbG7DkwDyhzI5jnmDaSrjFJECEFJY8gYgmdKebRp6p0q0Pskd6+pWfJ92FBD19+JOPb6wskUK36raGyhIpdGdYV+4NRg27qhuttx9uQwq6BoFdE7oHPF09f03dCh261b8rn+rCTDG3fiMiIhrPBvz//LFYDD/84Q9x6qmnorKyMvsDhsBms2HevHlYvny5so1YPB7H8uXLceeddxbseZuamtDU1IRYLHW67UilDyXjhbpRl1GlGxgdodtkElBul9b0RhMd8QY7XvXe1Oq1yepKtyAI+H+6irk3GEWnP6SEcPm/3X0RXH5q8iLXaY1uTHI70OIJIhiJozUSRKs3CEDaNk0/FbymXKqq/3XDEfw1sXWa7BuLjpeOtZqUhnpf+d0G6TURpArwjIll+PzZUwEkL0TIv+tD3f146r0DKHNYcFJduapzulzpNg6y8t+XCS6HFLrTNFpzWKWLAT39kZQKvHxMmd0Cv2ovcDlYmwSpkZ92PbVxpdvttOa0jZsoipqlJOrtwRorncpt8nNOrnRiS3OvtpmbQaVbvW2bdA6Ddd5FCd2q7c1CUcTjojLjIvtjjaaXD2xP9HRjGdJ68EAUk9wDeviAqd/Pvf0R+EOJSv8ALxYQERFRfgw4dJvNZlxyySXYuXNnXkK33+/H3r17le8PHDiAzZs3o6qqClOmTMGyZctw66234swzz8T8+fPx6KOPoq+vT+lmXghLly7F0qVL4fV64XYX+NNRnsgf6sZb6NY0UnNoQ3e5vtI9gqeXA4C7xKoJBUZrunPhclpxtDcAbzCqCWiZQrwgCErwmzGhLOP5q8vseP87n4A/HIWnP4Ke/jA2HurBD/65Az39EciZSH6+by46ARUlNvSHogjH4ghH49hyxIMOXwi7Wr3Kz/rZMyfjaE8AnkAE0biYCKxRbDrci+MSU2Llc8rTnDt8Ifzo5R2JnwH4+kUzNMfJQfa9PR2Yd9+bKLVbcObUShyfmBUgV/ADkRiefv8A6lwOzJiY/PntFhPKHBYpdKeZgj6h3A5/KNnQTP67WF1mR4dPapQWisZgt5iV4Oa0mhGIxJTQ7XJactrGTR/aY3ERbR7pgsfkquSacDlkK7dlmOLuCUSU9eDKbf1GU86LsKZbNQZRBPzhaMrf83Q0U9MTvxvtlmFDWSM+9PXlhaR+rx7tDUBeRj7QKfUjSSAcwxefWYcLTpiAryX+nhMREY0Wg5rjdsopp2D//v047rjjhjyA9evX4+KLL1a+X7ZsGQDg1ltvxTPPPIMbbrgBHR0d+P73v4/W1lbMnTsXr7/+ekpztfFuNO3RnU/aSrf27axvpDbSXxtpvAHle6Pu5bmdJ9ldXF2dy+fPL+2VLU1rn1xVAmfigoY3GFG+li8anFhXjgeuPVXz+G8/vwV/WX8E7arfzc1nT8XNZ0+FKErrp33BCO784yasPdidPC5x7pkTy3Df1bOxo8UHfyiKFR+3wx+KYm+7X/OzntLgRrnDAl8wiq6+MLr6wjjc3Y/rzmgAIK15lgPwD/+5Qxnfdy49STmPHNyfePcANhzqweSqEnzipIlKkJpQbseBzr6U6eXVpTZ0+kMQRSnsTCg3ax5zuLtfqUC6nVbV3vLpg5E6vMmV9ObEFHW50h2Ni2jzhjS3yXtvC4JgOC1ev22ffhsx+RzDzWgMuYZuw0p3vrqXD6FK7ukfhtCtCvbyEgb97aPN5uZerN7fhUNdfQUJ3fG4CEHI7xI5IiIi2aBC9/3334///M//xH333WfYSM3lcuV8rosuuihrN9c777yzoNPJx4LwOK10O6xm2C0mhKJxuEuyTS8f2ZVufZgYyvRyQNuVutAN9lwGU6MdGS4ayD9ruzf1goggCHDazHDazJjgkirR7b6g5jhBEPD5hdOUx1z3i/ex8XCvKsRLv+v6CifWfW8xOv0h9IViuOmJNej0h5T3hNNmxq9vmYflO9vR7gti7YEedPpD2Ha0VzqP1YzGSie2HvHg9Y9a8fpH0q4JXzhnmjJNW666/+7DQ9jV6sMVp01Szi0vGfhgXyeWzK5TKrcTE6Fb/XooF0syVrqTU9crSmzo7gsrAbvO5YDFJCAaF5Wu6JMTHdHVW7GlThuPwqp7b3gDEcTE1Cnnwy216VsUyHGClVFIVle6B7xPt6Z7+UA7nxev0t3cnbyQV4x1+fkij70QMy5icRFXN72HcrsVf7x9AYM3ERHl3aBC9+WXXw4AuOqqqzT/5yRXUkbTWuixQu5ePt4aqQFS4OvwhdI2UvMlqomZQuBI4NJV6gc9vdyRrJjKoaXQ26XJr31cTH44zjR+t2rLMiD91H93juvyUy6wqH7XDqsZjYnwKVef1Rdizj9+As4/XtrT/L9e3IY/rjmseb77rj4FC2fU4FhvABsO9mDtwW4c7u5XQt38aVV4ZWsLevsjeGNHmzIWh8WMylIbvMEovvncZpwzo1q5KKbvAq6udB/pCeBwVz+mVJek/Jzq9fJupxXdqn2f3SXSObr7wsrY6twOmE0CYnER3kAUJTaL4b7gZXbp9ZdDuzcYgdmkfa2L3UgNGFhg1XZ5jyb6FgyhkdoQpogPZT34YKh/V83qSvcoDt3ya+4PRRGNxfN6EbGrL4TtR6WlLvpdCoiIiPJhUKF7xYoV+R7HiDIqG6lFxuf0cgCYUlWCDl8IU6q0IcXl1FeOR/YHKf1Fg8H+Lt0Gle5Cr2e3W0ywmU0Ix+LK+tFM0+Pl3022ZRHyBYSe/sxBPnVP9swhXq6I6y/EpIR8qxnVZXalkdvr21uw9mA3evrDyoWuT502CYtOnoiv/2Ejth7xoC3RVM5uNeHuJSfiyfcOYNPhXuxs8eKkOmkW0MmTXHhte6vyvA2VTlQkZmpsae7FBQ+vwG9uORNnTq3EV3+3AYFIDDMmlOLf5k9Rzq1/f8vVck0QT6zT7+4LwxOQGsEpTeTK7VLoDkRQldhCrqbMjlav1FiuJBHES21m9IVjRVkPrK/KDyT4q9eDx+Ii+sIx7ZrugW4ZZrBGfDBjGY618ernkPsGSLeP4tCt6cgeRWWpLW/n1nemZ+gmIqJ8G1TovvDCC/Huu+/iV7/6Ffbt24fnn38eDQ0N+N3vfpeXdd7FNhobqckBYKQHy0L4+edOx6GufsycWK65PWW69kivdKvGazObcu7SnHIe1dZTw3UxRhAEuJwWdPqTgS/Tc6ZW9dNVsLXHpZutIB+n364s3XFyMNX/fcnWB0C+X97WTXouKZhPcjuwNdEgTn7sp06rx1nTqrDggeWarblOrCvH6986H7tafYiLIi6dLU1Jv2pOPd7f24muvjA+OuZBIBLD2oPdAIBtRz1K93a7xYRKg+UU+iDudiaD+PMbmvFv86doGsDt6+hLrN+WxjXRlQjdwQjMieZqE10OzZr14TSUdeVG26Cpw3IgEkM4Gs95Sc7QKt2DXw8+GOrn0KzpHsWN1PTbveU1dOt+P7UuR4ajiYiIBm5Qn8T/9re/YcmSJXA6ndi0aRNCIelDpsfjwQMPPJDXAVJuxuuabgCY5Hbi7OnVKbfnGuxGCnVgGspY1XtYy2FqOH721DXp6S8A6Y9Ntyd5rufMdZZAtnXz8numL2z8uumnsauP0Qdyeazy7bG4iB4l7JtwUp0LV89twLWnNypr2H924+n4zJmTAUgBSV/Zlbdmc1jN+PpFM3HhCRNwUl05bjt3GsrsFsydXKEc21DhhN1iwsRyKUD85t0DuOXJtUrAkG9X78ktd3NXX7CRbytKI7UhdFDXP7bLH0ZAt0bcN6Dp6vlppDYcFy/U7xt5zf9wPXehaLd7y+/Fg+H+/QyHWFzEv/9pE371zr5iD4WIiDDI0H3//ffj8ccfx29+8xtYrckPseeeey42btyYt8FR7sZz6E5nQpm2WpEu2I0ULlUn9qFU5ZON1JIdqIdjBoS+yprpvZhrSE45Ll0FO8dwnrLkwGpcyU53Hnk88rpokyCtg1bf16UK1oBUnZe35MqlqZ98Hk8gdZsydeO5+cdV4dkvzsfr37oA9145GwDww6tm41/fugC//9ICvPj1cyAIAr5/5SzcOF8K8sc8ASV4yuvKNaFbvk21T7fczE4OPduOeLByVzsAqY9Hb39ydkO+DWWv8NQ90ZMV3xKb3G1/ACE+OvhGavp9ugstXXAcC43UgPwHY3Wju9H8Gql93OrFP7ccQ9OKvdkPHoTffXgIT753IOX2WFzE+3s7DS9oNXf349VtLRBFEZ7+CH69ah9aE1seEhGNdYP6ZL9r1y5ccMEFKbe73W709vYOdUw0CKFx3EgtnVMaXPjR1bOV8FPvHtlTBrWV7sGHZPWWYXIjteGYWq8ev9UswJxhenyu6+1Tj8vcSG3gx5kz358llDusZqWZpPxY/Zp2eQ90QFVBz7jePdnFXB8yO/yZQ7sgCDixrhznHV+DiYkpsqc0uPGDq2YrY5Mr8RMTAdsXiqI/HNXc5g1EU6rfvsRYvvzbdfjiM+vQ7gviFyv3Ye6P3sTKXe3o9Ifw2V+txgsbjwAAXt56DH/ffDTtz5mLYEqle3CN1IBkQ7FyhwWViTXsA5qurluXnW3XDc1YhtD5fDDSBXt/KIp4PPdxjyRD2e4tG22ju9E7BV9N3prOV4DfeTASw71/3477Xt6R8n5+46NW3PTEGjz02scpj/vO37bi63/YiA2HevDcusN44NWP8atVqZX4H7+yA5c+ugp9obHxuyAiAgYZuuvq6rB3b+rV0/feew/Tp08f8qCKrampCbNmzcJZZ51V7KHkLDSM4Wq0EAQBtyycho3//Un85asL8bkFU4s9pIzUVd2h/B6NGqmlayyWT+pKfbbny3W9vfqcQO7Ty9NPV8+85CBbBb4sw+MzjTUlrOcw9d4biCghsy4RoLv8g9tz3m4xK+vh5Wp5TVmyg3pXYi2+XOn2BZMXbOTbPIEIorE42rwhxEXpPJubewFI1e9393Rg7YFu/GHNYQQjMfzHnzdj2V+2wB+K4ncfHsJFD6/A4S4p+HqDkZxCqxyG5E0yBhKIUivdUkMxl8OK8hy2Z0s3FkCq5vWHc2+0OZT14IORLtiLYnI3h9FmKJ3nsxnu389wkH8OUQT84fz+zr2BCOQcr993/mDi77h6S0TZsV7p7+DR3oDSzLJdtVRH9uKmY/i41YePjnk1t3f3hXH+T97G/7wuBfq97X5sONQztB+GiGiYDOqT/e23345vfvObWLNmDQRBwLFjx/CHP/wB//mf/4mvfe1r+R7jsFu6dCl27NiBdevWFXsoORvPW4ZlU2q3YP5xVRkrryNB3irdyp7ZyQZZw13pzvZ8uTdSy89a7XTn04dzfXDW3282CSi3q5YBqIN1yrmTYyjPcZq8+jzeYHJNd2OlEwCUD7qD+X0qTeISwb3cYVHGKN8mB+y4mBrEvcGIbl1tshLvDUaUD9/eQASeQASRmIhYXJp+/s8tx3Cwqx8f7OvE6n1dmPvDN/Cz5dKF250tXhzq6jMcsxyGqhNNswYUkiPGoVu9Pdtgu6EPZSyFDnXhaDxl7braaN02bCid57PR/H5G6eujp36N9MF4qDLtdy+/v41eR2WvdfW/HQbHpTvH5uYeNHcH8Hpi54dbnlyDG361Gt19YSzf2YZrmt7Hvg4/wtE4nnh3P/a0+Qb7IxIR5d2gPol/97vfxec+9zksWrQIfr8fF1xwAb785S/jq1/9Kv793/8932OkHHBN9+inDo5DaqTmTFZKg8O4lZx7ABcNnFazss450/E5r+nWh/g0x2WrZOcS8tNdXEg9t7rSnXtTP7fq9yd/cJZDt9G5c5WyTZvVrLznehMfyl0Oq3LhrkM3DT0SE5Xt0IBE0FY+OEeVQK5fi+7RhfOtR3oRF6UP0N5gBNc0vY9/+/WHAICtR3rxyBu78MrWFviCqmZuqqZvudJ3L29OVN5cTotmL/tcpXZSH9x68EJPX87WHG60VnI1IbKA08vHypruQq6BzzTrQPk3QdcvQRRF5Tb1BUX93+lgYleBjOcORBCJxXHME0Q0LqLVE8TzG45gc3Mv3trRhpW72nH/Kzvx41d3Zvw5DnT24dpfvI83PmrNeBwRUT4MasswQRDwve99D3fffTf27t0Lv9+PWbNmoaysLN/joxwxdI9+6uA4tO7l0nnCsbjygWZYGqkN4KKBIAhwOaxK07F0W4GV6yvPOXcvz7UbuvZ59c9ndB6X04qjiWmSmunlGQJ7ruOTxphcky9/yJys24M+3euVidEFB5fTqpneabea4XJa0ekPKf+mVJXaYDYJiMVF7Z7PgSh8yofoCMoDqrXoQW1V0qsK5/HEtHJvMIo2TxChaBwtniCCkRh++M8dynTR2fUuHD9R+v+UieV27GyRPnSLoqiso89EDuwuhwXeYFRT6S61D216OTDAKrkqsPuCEcTj4qC3BMwm27hGa6gs6PTyyPA2uhsO+r+DeT13QDvjRXuf9L3+fdYfjiGWmKqjXjqjD+eZ1u7Lz6vvd+FR/VvpDUaSU9e9qVPX1ZbvbMOmw714fsMRXDK7LuOxhbSvw4/GSue43PKVaDwZUkKz2WyYNWsW5s+fz8BdZMPZpZoKQ7ume/C/x1KbBfLn+XT7TReC+qJBLhd/cplOr16LDAyke3muFXHt86Y8n1Gl25FmenmGMWRr0KYdo3SsLxRFT6Iz+ORKbegeVKXbYOq8cRBPPU5+rLoDuL6CLX/oDUbi6PAlO5prKuKqQK6+qAAAvmBUU0nf3eZTZmrIU9w/bvVh3v1v4YO9nQCAd/d04B9bjmHrkd6UKbTJvcelKrk85drlsGrWzedqKHuGqx8bF4G+PK+xVZNDTJndeHbFaAyVkVhcs4a+oI3URulMAD39vuZ5PXeGCyBKNTug7dugf4z8PtSHc22FPmp4nzTrRrsVnnx+fQDPJNfjCmndwW4s+uk7+O+Xtqfc9+aONnz1d+sLukMEEQ2fQVW6aeRhpXv0c1rNsJgEROPikEKyySTA5bSitz95xX841nQP9KKBNrxmCKEOK4KRzF27UyvUgw/nmuczeN3UAVod0DMF+lwvCgDan0XeTqexSj+9fBBruo0CtkEQNxqry2lFT38Ezd3JSndPf1hpyuUNRFFmT35wVYfznr6w0rXdG4gglvgcnlIRD2pDeCQmKhcd5k6uwOHufqw/2I3uvjD+9VErJrrs+PyTazVjdTutmFZdgq9cMEPTfX1vu1/zOgym0i03lpP/jg7mscmfNYpy3eucL3LYaqhwYpdqTWtjpRP7OvpGZahMqXgOYKu3XIzFRmqeDBXjfJ47XWiOxkUEIjGU2CyGj1FffFPPXtFW6I2r6ID23xj1UhxvIIpSe/r14kbn8xTxQtSuVunv6B7Vv1Gy37y7H2sPdOPSU9px7emNwz00IsozJjQDo7F7ubJOk6F71BIEQQlGQ91TXGmalcO+0PmiDmuOgVa6M1wU0K4VNz7OYjah1Jb8GdO9fu6S7OE329p07TT65P2Z1ourA7kgZG54qK62RxPTMRsr9JXuwTdSU5/DMIgbTIWXH9us+qArT7EHtNUlAJpp6Jop6UHtVHP1Y3r7I/DrOmurm7795asL8d3LTlLOI18AcFhNmg7rW4548LPle1L2Hpe5nVbVFP6Br+lW728+0MfK8t3YSnPuxLgqSqyapn/yEoXR2CgspVlX3ivdY3F6edTw67ycO0NTO1+a+/Rf68O54XFp1nQDQLPu3xXNbJrE19m2S1NX5YslY+O5xL8Thfz3goiGDxOaAXYvp2KRw8BQL57IIa/dJ1VKh797eQ6V7hwbr7lyCN1AbluuldksUC8HNgrn6SrZhs+jGo88U8Ho3Pr17tnWJOsD/IRyu+a5BrP8ILUpnUFV25pa/VZPOW9WbQOkDdMRzYdl7XHaipT84TgQiSkd0gEpxMuzUeULKPJFI/m1VE8Ll88zb2ol1n1vMT764RL88qYzAAC9gbCyjeK8qZWa3+OUqhLltXh56zFc8bN30dzdj0gsjj+vO4w/rT2MlbvasafNp7kIENJNdR9IdUwei/zvcyGrqfK5Xaou7QBQX+FM3D/6QmXKut+8r+kee43U9Gue83ruYPpgrP4+XbW9NxDW/N1KVzlP1xkd0C116Q8rDQTVVe9sW+Spl8cUS3Kafeo40617J6LRidPLxwBRFJVpqJxePrrJH5KHHLqLUukeWCO4XBuvac6bIWy6nFYcS/w9SPfzmhJbfskfYgayZjv5POrxJB8vz1ToTjSHS9dILZffhcthVdYs2swmOKxSBVoJoYOaXp4+TKvHZrStmjz+o5oKtjZMl9osqvuSxzXrwnlUVXnSHJcI6g6rCTXldvR19SuN2uTXUr0HvRIuE++jUrsFs+vdifFElWmtJ09y4cN7FmH7US/8oSgWnTwRLb1B1LkcaPUG8dExL1bu7kBViQ3f+du2lNetqtSG+685JblGPBG61xzownt7KnHe8TUpj9FTV8mP9gYKWlmTP8Sr9yMvt1tQVZLYdm0Uhkp5zIIgBam8bxnG6eUDkq7ZmSiKaSvV6q+P9QahWu4NbyCKSW6Dx+h+z5pKt2qpS4snqGyn6A1GUWLTjk9/wVF/Pn+iIl6o5oaZZFpXnq7DOxGNTgzdY8Dj7+zH6v1dMAlSVYdGL7cSuocWkpPhJH24zLdcpoGrqQNfpun02SrPynG5hninNfm6ZKl0p1vznbw/dZ/vZOg23sM7t9fGqvraAkEQ4FaF7sFUuo2mlxtNidffZrOYlMeqq0bqRkZxEZomaOpp6NpwHkU0Hje8T7OPdspYE5Vu1R708gdRt+61AqQquhzYHVYTKkpsmnA8pboEq+/5BO76yxa8sOmotL1eYt35hHI7qkttONYbgDcYRXdfGC9tOqoEs8ZEU7sP9nXhg31dePnfz0MsLuKuv25Bmd2CGRPKMHOi9OekunJMcjuUCw01cuguYOXKo3pd5NdGqnonu+KPNvLPVOdyoMUTzHvlNhjRNmnLtUP+SFbIbu/pqtHBSFyZdQekr7bL/0YajU89lTqliq4K4ep/O5p1FwBLVEuNMv3s8n1yRTxdOC8keQzhaBzBSEz5/0J188CxciGIaLxj6B7lXt3Wgv95/WMAwL1XzsYpDe4ij4iGQg4bQ50OPpDGXflSniGMGsk1pOdaJR7INHQ54GUP1Vn26dbdn26Ku7Zan8ssgOTx8vMNdCZByjkzrNVWn1d9m9UswGwSUh5rRF3BVneaVodzTyCibBsEaKtV8odol8OaWoFPvGby2NRryNVjU78Hu/syz/IQBAFVpYnqbzACq0l6jstPqcMPrz4FAPDCxiNY9pct8AYjSui++ewpcDmteG7tYbT7Qmju7sfmI71Ks7bNzb2a5/nxtacoX08ok6rkb3zUisZKJ86eXg0A6PSHUGqzwGkb+oyU5PRyS/K9o7qQMRo/wMtjnlxZghZPEIHEXs75mtmV2l0+ltL9fbTRVrrzvKZbE+hzm2qeaQzpgnam86Vb6uLRh+4Mz6vf+qwooVvXZV4O3b6g8fR7Ihq9Rvf/qxAqSqSmQNed0Yhbz5lW7OHQENWUSSFAH4YGymjbp0KzWUxwWs0IRGI5BsvcGqnlXsHOcRp64nwmAZo12LJsXdgzXSxIF8hzXb9udLw83oFWy/XU4zYJUqDWn1OaIp86vV6/znuwArou3uoKlfwh2rjSnQjdcrVWtYZcPTZzYvmALxRVpptmm/UASB++rWZBcxsAJZR394WViwUTyhxY9skT8NFRD5Z/3K5p3HT5qXU4qc6Fve1+rD/YjWOeID7c362cb0qimdkbO9rw1s42fPhfi/DPLS247+Udys8+ye3ANxYdj8tPnYQtzb3YfsyDercT58yszum9I49FvTWaWxXAR2OjMHnMDZVO4KB0my8YQXWZPf2DBsBoO7jRHLpD0Ziy3R6Q/wst6fbp1s+iyFS11pwv7Trw9NPL+1QX9lo8yVk2oWhcmRGU7Xn1FfvJaY8sHM1Fi0AUE8uT41HfTqOPLxjBd/62FVeeVo/LTp2U9jhRFLG7zY9pNSXc9neMG73/r1JATU1NaGpqQiwWy35wkZ0zowavfON8THI7ij0UyoMvnz8dLqcVnzlzaNuDFKPSDUihKBCJwTHAYJm5gp371mKyTGue5fPZLWbDKaTZnk8d8vQXM3LpbJ7L70J9vDJFeIAzCfT0jxcEwfCChuFtBaoAqSvicjd0l2Ho1jZS6w/H0JWYoqqvTrmcVs00+Fw643uDEeUCjHa6urY3gvp82qnu0vMtOK5aufj5m1X78eNXd6Ij0czQahZwx0XTUWo34+n3D8IfiqKlN4j1B5OhXK7g/+bd/bhkVi1ufnKNUvH67JmN+J9Pn4bbnlkHi8mE39wyDx/s68IzHxyEzWJCud2CMrsF2456lJ9Dfi+7HMmp5l19IfT2h1GRWOM9GsgBpLLEhjK7Bf5QFN5gNI+hW/v/9Z5ARGk8Nxr59I3nCrhlWLrALN1nHM710nVD9wUjylrreFxM2d1AFtN1KO/LYU/3cDSu7ZpepBkg6fZTL+Q+6zQ83tvTiVe3teJobzBj6F61pxO3PrUWnz97Ku67RpoZtb/Dj2V/2YI7L56JxbNqh2vIVGAM3QaWLl2KpUuXwuv1wu0e+dO15a1gaPSbXFWCuy45ccjnqSjVfqAezBrgwXA7pQZgA51CnWuYzvRzyKHCbBJgydDFXz5fuvXhmvA+wDXf6QJ7eYagnm0M8vPl0p094zkNGsAZzQ7QrqHXht1CiiQ28FaHxeQ4pPGqX0dlOroudKfu2Z79go43kAzdmtc+8XWPqmIndyBXth1TN3VzqpcFyDsIJKe5Tyx34K5LTsSbO9rwcatP89j7rjkF5XYLvvXnzYl9jKOa8LSvow9dfWGs3NWReN4oHnt7j6aSrlZdZkNlIlhXltiUn2VfRx9Ov+9NPPLZObhkVh2uf3w1WjwBVDitcJfY4HJYlG3r5P86rIn/WsyY6LLj6rkNcFjN2NPmgwhganVhKzTyayRv9+YPRfMaJEOR1Er3aKYPv/oQPlRpK9Mpa7Bz66Cebop6XAT84ShcDit8waim+VruYzX+2X0pYy1ONTnda1TINfk0PHrlfeD7wxmP29Mm7dW+V7VX+1s727C5uRcvbjqa19C99kA3WjwBXD23QbmtwxdCMBLTZIlILI64KLLynmcM3URj0GWn1OHDfV34uNULi8mEs6dXDcvzKmvSB1jNzX1Nd/apwtmeO1uzuqyN1DJMPzcKrPJzOawmBCPxATeZk8Od0bTvgTCqYBu9tkYXQ4ZzraPLYUlb6Zb3Y+8Lx5R1nPrQndp9PfsFGG8gArMpdXq5PvzbLCalw3Gy0q1aX24Q2JPbnplS7lNXyRsqHJjkdqpu103VDURSpvL29Enf37JwKiaU2eEPR+EPRlFZYsO5M2swvaYMu9p8uOnsKTihrgxnTKnAtqMeRGIi1h7oxiS3EztbvACkfdLR1Y9ciCJw0iQXrml6H4C0XGFKVQlmTCjDjIllmDmhDDMmlmLGhLK8VNSVKfOJafLHPMG8BpGgrtI92rdoMnrv5IvUoVzbPC0UjcFuMacE11yDY8ZtwgIRuBzWQf++011AKfQ2dLkQRTFtdZvTy0e/5JZ0mX9/yn7xBhez9LNwhurOP25Euy+EM6dVoSExm+e6X76PLn8Ya7+3GGV2C0RRxJWPvYdAJIblyy7MWMSggWHoJhqDasrsaErsWTycXFkCrdGxQPatwID0a7CV43Lc41wZYw6V7uxbiukq3Rke63JYEYyEBrydmuH08kFUussNtkLLFsRtltSKeKG5nVa4S3ShWx1YnVb0hWPKVFN9QNd/b8s060HV5T8ZutUXPNIv01A3dTPupJ7o+K7sIJDazV6qaKvWYBtsiSbzJqrfyveqYz4zbzJObUydlTWlugRNn0v+O/DC18/FM+8fwA/+uUMT7E+qK8d915yC3v4IfImmccGItC44GIkhGI0hFIlj9b4u7Grz4VhvACbV0oy4CBzs6sfBrn4s/7hdM4bqUlsijJfi9MmV+PS8RuW1zpX6okYh1qaPtUq3/D6pddnR5g3BH4oiGovn5cNzXzgG3Wxu+IJR2MvMGbuNZ25olqVjeeXgLxyke5xRuB9ugUhMmeEDpK7vTt4eKdqWZjR46i3fMu2IYLRfvPz71/ebGIpYXFRmXrV7g2iocCIYiSkNTVs9QcycWAZ/KIqPW6Xqe09/BBPK87OMp7df2gnkyjn1eVsaNNowdBNR3siNompd2f9Blae+moQsa7CV6eDGa7CV43IM/NnCebZGamV2C0yCFDQyNlKzpt7X7gsNuLO7ugO1cu5BrNG3mE3Kelj58YZB3ODnTw22yb3ObRYTwokPBvLrMhTGa7q1e56rGyfpq/Dq7y05LjXwBiLJCrZueYHdYlI++GiDszy9PGrYST1jYFc1hFNv8SW/N8PRONoTXd/lyr76WGnM6ufN/f/KtcFe+h1OdDlw1rTss2Ee/tfH2NXmgzcYVT4gXj23Ht+7/GTs7fBjX0cf9rX7sa/Dj33tfhzzBNHVF0ZXXzfWHuzGn9Y2o9btwIUnTFDOGY+LuPv5rTjQ6Ued24GJ5Q7UuR2oddlRW+7ARJcDXf7k+n31xY58kX+/8t+P0d4tWh7/5MoSZfcAfyial1kH8rltZhPsFhN8ian+NWV2pXFaic2M/nDMcLq03OgQkBrB9vZrLzDJ5zCbBMTiyUrwYENxugq2/nzFCN0pMwPSXHwQVdPsafSQf4fRuIj+cAylaZozKqFb9X5QKt2R/IVuv+airfS1z2Bph/rvbT4r7b9bfQg/fXM3Ov1h/OeSoS+jHI0Yuokob/7jkyfgvJk1uPDECVmPrSq14a5PngCnzZwxGE2pKkGJzYwZE8oynk8O8SVZtl2Sq6jpp5dnXmsudfiWPiwa7dMt01dY3Vkq7NoxpFa6c906LeN5E+th5TGop2sbrZs2aqRmNgmY5HbCG5SuhDdWOLG/sw8AMMntVBqi2S0mmE2C0ixN/hCddYy6Nd2CoH0tUy4A6AJnro331Md6VKHbqDGbsj+6LvzLj5U/wBjtGS6zZamSu5xWlNqSF3Tkzu6Tq0rwcasPwUgcnaqGbt19YeW1Hcj0f/W4kxXk3D4KqC9SeBKPcTutmOiSwvE5M2o0x/eFojjQ2Ye97X40rdiLPe1+tHoCmmP2d/rxt41Hcnt+1XvjH1uOwu204orTpAZFwUgMNrNpUNVA+YPlhHJ7oknb6A7d8nuqqtSmBGBvID+hWz3V324xw6e6SKHe2k26OJM6dbqxqkRZ0jC5sgS9/R7l8fG4qATySW4HjvQElMfJx+T670jyeY0r7KnbkQ3/FO5MW6Klm2ZPo4d+tkLa0J34vasbB8q35TP0ai/apgZso/Cfz0p7q1e6WN6dZY37WMbQTUR543ZaB9T0498XHZ/9nCVWvHP3xSi1Zw6ap0+pwGfPbEz54K93fGJPlmk1pYb357JFmcuRCN1W42BtVGHNdfq7fgzKlmE5bp2W8byJ9bAO3VTnvnBMCfLq9edGjdRcDosm5DVWlSihu6HSqelCbhaSoVv+EA1oq+N6+i3D5K3MkuPVhewM08uzNRCUj43GRaVEn7JG3GFJhm6DddmtnqASAoyWBRiNRX6OVk9QmRngdlphMgkod1jhCUSU16q+woldbT6IonY/4qO9yfXXA9neSr0W3WhafCbqbu/lAYvmNiOldgtOaXDjlAY3Vu5qx552f0oI6k1UNmvK7Ljz4hlo9YbQ7g2izRdEW+JrXyiKercTJ08qR2NiHeKH+7vx4f5unNZ4MT7Y14l7XtgGkyBg/nFV+N2XFihT2Dcc6sb6gz1wO6345KxaVJfZ0e4LYn9HH2rKpKnv8gfLCWV2HOjsG/VraLWN56xS6M7ThQT1RSK7xYyjvYHkmtTE69ZY6dSEbnWYnlyZ7CMwucqJbUc9yuN8oWSztMZKpxS6detd1f+OAMnZCYDxTJt0P/dImF6eOob03d7lafY0euhnJk1K05dZ/r2rGwfKv/98hl6jHgtGF3rUt+Wz0i7/Xc7nOUcbhm4iGvFyWVNkNZvwk+vnZD3ulAY33r7rwrRbAlWUWHHeTCm4pwsz6ZqxZWrmNrD17snnVdZ0q27L1Bws83lTq+3ydG19oFSvP3dYTbCaBURiYqLamAxakyudqq9LsPZAt3JekwC0epP3yR+W1dVxudKufu5M28npA3nKtm3qZnZZLk6U2MywmAQpdEOqqpfb9ZVz47HIt7ckKrdWs6D5vejfO9r14NJ98t7k8lRd6bwWeAIR5b6KEivK7Bb4glHdvuYB5XkGslZXqVarpojnuiWcei16ucHFoFwem666V1/hwBfOPc7wsfHE78dkEvCVC2eg1u3A//5rF3r6I2j3BfHe3i5I101EfLCvCwe7+jBjQhnicRFfeHqdMoVy1Z4O/OzfTsfl//ceOv3ShZQ7LpyhfAickFgWI4/pf/+1C3VuB24+eyo2HJJC/h0XzkBfOIq/bzqKy06dhJoyO1bt7kBDpRMzJpShxRNAmzeEuZMrAEi/Y5NJQIXTihJb5iUy+aJe7uByWtDqzV+olD84uxxW5T2rr5rJXZCNw3SyQ7L8tX4Kud1iwoRyh/G5Vf+OWEwCal12+Dvk6njyop8ydT1dI7XE2ARBmr5djNkNKcFaE4qK3+iNhmYwjQTlGQ2eQoRug0Z92iUN0ZTx5LPSnryQMPK3Yy4Uhm4iGnemZ5iqLggCfv/lBRkff+s50/DSpqNYOL1ac3tjhVOafm0Q6AfS2V27ZZgl5bbBTy9PDf5G40quP5duk/f07uoLJ0Jx8v861NuMNKoCuMth0TTbUt+nro7XVzixt8OvfCg3qnRrfgaDqffanzF1G7R05KUC3Yk9v8vtlpTpyernMOpArq5UqwOVeg299NjUfdublW3PLMpj3U4rmhFIdmd3WJUtk46oQrf89UA7y6u3STPqup7xsaqu6x7HwKrk6qnparmMQf07KbNbcNOCqXhubTN6+j2Gnd7l730h7bZrzd0B9PRHlMANAFuae5Xu5RMSzX28gQiO9PTj5yv2wmYx4aYFU/Cjf+7AliMenD6lAluPePDQax/jSE8AN86fglueWosTa8vxr/+4AF9+dj12tHjx7rcvxvKd7bj3Hx8pz2UxCagokS4qVTitmH9cNb572Ulo8wbxzq4OXDW3PqctBbORA6X671K+Qps60MsXtfRVM/nvutwATBumkxdQ5eP0FTZ1f4NkOIhqHiMfp37/qWfaNFY6E40BM08vr3M50OIJFmV2w0C2WBvtzf3GI/1uE2mP0zdQq0wG4GCkUNPLUwO21yCI5zP0F+JCwmjD0G2gqakJTU1NiMXG79UYIkrv+nmNuH5eY8rtE10OvPC1c1BVmrp2cvGsWrz9cTsuPmli1vOr11XLH5qHuk83kAxcRk291EHcqJLvdkqhWx+K1R+CJ7kdyhRPl9OqCd3pwnlFiRXl9mRjNmlbqNQ9xZXxql8bo9A9wIZzLodFCd2G50tzASDbNHf53HLo1l/UAKA0uTJqwKYO1S6nFUd7A5pptc2Jr/X7kmcj/26jcRFtiTV2Q5lenmsTN3XjOTV1QBwIdTO6dOtzjSqJRpV2udI9MVHp9gQiyrT3cDSOQCSmLDHo9IfRmmjk1+oN4lgi5Mlh71BXv7IUYMuRXs1zReMiOv1hdCYaw2083IvPL5yK/3trN/6y/ghMJgEXnzgBd/5xEwDgtEY3vrHoeJTYzNjb7sfU6lLYLKaMnZDlnwmQ3n/q2Qn5oF6SIL+n9aFZrmDLDcA0YVp9wS5xnD8URTwu6ir02osF8n11bocyO0U/66ax0om1B5Ln3n7Um6HSnbxA0OIJFqV5ntw0Tm7WmCmkjfbmfuORx6AxmhGjBnrDN708tZGa+rZCPD9DN2ksXboUS5cuhdfrhdudZhEGEZGBOYlppXoXnjAB73/3Ezmdw2I24ZOzatHiCaAhEVDLHRaU2y0Ix+Iotw+uoY5hVdvwtkQQVwXectU0d/mDriBAM01fruL19kekyq/88ySmgcomq6aYyqFS3YzMaU1O+043hV89TrVc93U3Op9h5TzN/ujlupCd7gLAsURAM3rNjb5XT/+Wz+FOjEHdtf2IUiUf2HtB/drKU9QHGpw9gYgyfT7XKrkS2NNU8Aa6LZ2mqVviHMpUYYMmQfKxRmEmpK90B6O6ABTVBHl1RUj+IOkPRRGKJreyUx/342tPwbWnN6C3P6IE+q//YQN6+iPo6Qsrv9dWTwBvf9yO1fu7AACr93fhxLpyVJXa8IWn1+HWhVPx/Stn4/rHP0B1qQ1P3HoW3tndgbd2tOF7V5wMu8WEw939aJcvppQkK8b5quSqA73890E+t/zfCeV2TZDUhGmDC3aiiEQX9KhybvWsCvXzytVtadaNRXO+yZWpF/Z8oShicTFlmzqPErpLsO5gT3GmlyfeU5OrSrC33W8YgORt30b73vHjUbo92NUisbhmeZUnEEEwElOCaSiPlW6jngFGF3o008sL8Pz5POdow9BNRDQC/eaWMzUVLYvZhN9+aT7C0TicWTq0pyN3eFc/Xg5tDoNGX5qGa45kyFJ/XaGr0roTodvlsEIuxumngWqnocsfxAMwCUCpzaKZ9j3w6eUDm4ZvFHjTny85FrNJ0Gx/lL1KnrrdmCxT13N1sFB3bQ4mqrMDrRCrX1u5SjvQ6eX94VjG2QGZHqsPwgOd4q4/nxSQk1OPm7sDKZXXcoe0Jl69vZvczK+nL6wsEZCnPquDIiB1ilfCtKparj4fABzrTV4UUY/L7bSixGZBic2iXKSqLrOjJ7FdVnK8UTis2tenyx9Wtkzb2+FHiyeATYd7AUhrIx95cze2NPfiwhMmIBSNY+kfN2peI/n9sfzjNjhsZjRUODDJ7US926lZ1pArdYC266aXJ7e/syhd/6Xp/8kwrX6/1pTZlaaN+sZ+6pkMgOriTKLnQ1dfOGWnA/W/K+qZNb5gJKVzuxJ45anwRagky885udIphW6DANSY2PaN08tHl2AkpmkWmu6iiX75g/pCHlCY6d3q8egvLupvy9fzi2JymQkr3URENOLoPxCfPmVo7WuvnluPj1u9uHH+FOW2WZNcAIDja5Pr3N1KEE+dEq0O0Oqqt3yM0XR4fYWrodKpVCXVH5xdiQ7eQHLad0qjNIf2vHqZpqYbMWpap5Zp33aX06qE7qxVcoP14OrzpLtPngmQdvyD2EbInQjdcgO5XIO7eip7V19y7+xcZGukNtCKvbrqngwvJWjuDqiCmhzGpW2qYnFRqSpPrnRiX0efpsqkhG7dNHR56rh8To+qIqSuHsnN75T7VNXZlPGrKtDqqpO++Z++u7D6g7MvGEVP4vfQ0x/GgUSfBPn8pza4safdDyDZ7V2t1GZGZakNggAIEBL/BWbXu/HYjadj85FePPXeAfzX5SejosSK+17eiVW7OxLnT4butQe68ehbu+FT/S7lrv/Ld7ahzRdM3q56LcoTITwYCeHJ9w4o7yn1vxf66pt8bvlr/ZpuWbbt0tRbmAFAXziGaCw+oKaEQ6WutgPS71pMNLeQ31eTK53YcKg4lXgavEzr9TPdrr5YB0hLUvL1vszWqdyoo3m+1pSHonGEY/G8nnM0YugmIhonptWU4pc3z9Pc9pkzG3He8TWY5HYot10/rxGHuvpx1dx65Ta5itRQ6VQ+wFaW2DRBzK0J0BYIiQnm+g/bFc5kR271B2yjQJ1a6c4ckjN1Pjdi1LQu/fm0Y9Guvc/9sfJe8UaPNdonPFOwHui0bKOx5hp49c3hBvJY/XRhmTpMDYR8vnZvUPkwpzTw0lVsal127G2Xuu8fUe1/vq+jT3NOOXT7Q1FlTTdgEKZV51d/QFV3l8/WqE69Pl69LZb+IlPKNHfdOlF11V3+eunFM/CtxSfAajbh82dPhd1iwsHOPhztDaLFE0CLJ4juvjD6wjH0hbX7pgPAwa5+fGvx8Xj2g4N4eWsLTmt0Y3JlCf609rByzJSqEsg5YG+7H4++tQeANANEXWH/6Zu7lcdUldhQUyb/22GFxWzCJLcTbd4QnvngoOa1kR+/p92P//3XrmRjQdWFPnV/iXK7RdNLQ55Bk267NCV0q5bH+IJRVBr04ygUZV/zKmkMkZiIYCQOQYDqPa3tBE+jQ65r8o2WwOhvC+crdKsv2OkaFKrHUohKt/qc6bYLHQ8YuomIxjFBEFK2TzutsQLPfnG+5ralF8/E3MYKXHzSRIgicN0ZDVgyuw52ixnnH1+DDl8Ik9wOTK8pw/t7uzC9pgw9/VLlqqpEGxzlD8u+YFRTydVUx9N0e882HbzMZlGq6LlVunOfXq7fqk1f5c/0WPUFAPUYgdRZAWr65lN6A51enu45cn6sqjmc0RZr6Z9TO11Ypp56PBDyhQs5jJkEacso9XPo1wF3+sPK8RPK7Jr94m0Wk/I6iKK2uq1uYKedXq5dI55yXIYLCur90tUduu0W6esJ5XZpenYwmqx+6irw6iq/dB7ptawqtcOa+JBearfgNoOt2ALhGFo80lR8Ecn34tI/bESrNwhvMIKexIWH3v4ISmzS3+VTGlz4xieOxydOmggRwIPXnYpDXf3KNPmzp1fDYTXj9vOn49fv7odJEGC3SBdrvnjecWisLMEPr5qNhsS/Of/fDXPxzy3H0Nzdj+aefvSFYrjm9AZUJS7sdfeF8fMVe5VxVzhtmot08uuovziVbbs0+XWsKrMp2xZ6ApHhDd2J31etywGzSUAs0UxOXn5uEoBJFdLFUDZSG108uosk6WYq6G/3BFKbPYYicZTk4W2pnV6eun7baxDE8xW6PQUI8qMRQzcREWXlclhx2amTlO8f+exc5evffnE+RFHa2um/Lj8Zn57XiDmNbniDUWw83IvrzmhAVZkNVrMAi8mkVL6P9gY0a5bV4dKoqzqgDYhGYdGUWGvtDUZzaqSW7XzpGqkBSLmQkPpY48CuHqP+uJQ13dkq3YOYXq5/zEA6oKubw5UZbLGW7Tn7wzFEYnElFGaagp3L+ZpVDeUqStJMSU5UPTv9YaVqLV/4kbcPs1tMsFvMyhpjdXU7XQU7GIkrncgBbejuSVSS0/1s8vhbPEFlrb4nEFHes5MrnejwhVI+FHtUFfiW3qCyHl0T8nP4fTptZsOtE2vKbVLoVk179wQiKEuc86Q6Fy6ZXaccr16qonbZqZM0/16o3XrONOXr42pK8Y1Fxxse97evnYONh3pwoKsPBzv7UF/hxEl15ZhSLVV/p1aXqP7t0M6mUVfB1xzohsNmVi6+uJ1W1cUe6XF9aSrihZRcAy9NmZfX+Mt/o6St5aS0xenlo0u6i4spxxmEc/1ForxVm9WN+gLSxTyjveG1a8rzMxW8EOccjRi6iYhoSARBUJqmOW1mzE10cHc7rXjwulOV4371+Xmwmk2wmk04rkZaZzt9QqlSVTSsdKdsGZZ5OjggVUGl0J3L9PLMW5Bl6oauuUiQZsuw5GNT14MroTtD9V7fhC7lOYZY6S6xmZUAPNDHDiQoq4O9LxhVpgIPenp54rVXtl1zqNYB65oEuZ1Wpft+szJNWeoKnwzdZuU8wUhIuz2bKoB394XRr1oHrg7k6uPUjze6qCGPX/0YbzAZuhsrS7DxcK/mA3hcNO5gD2jXew9m9oMyLtW+3uqp6+WD3NptKOZNrcS8qal9LO68eCbOnl6NhdOr0dMfRkOFE5efUodSmxnVpTb0haOYUG5XlsH83/I9+L/lewyfQ76o1eIJ4t5/fITacgccVhMcVjMcVjPsVhMsJgGiCGVGgAjpG+l7UZklUGK3oKrEispSG6pKbagssUlfl9gMm1/qZ2L09EuBS/63VLogIK/9Z+geTYy2KzSSOr08mvLYfK2B1kzxjsUNt6kTRVFblY7ka3q5qnqep3OORgzdREQ0LD5xUq3y9UOfPg1fuWAG5jS6EQjHYTEJmD+tSrlfaeamC6tlGdY/y+Ru6APdMsxwTXeGbugDqXQbT5M3uNig+lrq5m5OuU3VxHzA07Kl58j+GqZ9bJbp/emo14N7AhEldHsHGRQzNZxTdwMHEuuAE6+TvN+2eg9rIPn7cTmtaPdpQ7f6a/W0c/196hAsh/HSNBc15J9XMyVdXemuSk6VF1W/72aD55Aem1zTPZgLMfpx6aeul6t2LCi2UrsFF54wAYA0NVu9FeNf7liIYCSGMrsFX7lgOkLRGLr8YeXn8an6EcyYUIpSmxnH1ZRiV5tP6QpfCA6rCTVldkxyO1DndmKS26Fc8FFX6Xv7I8r2Zupqvb7LNY1s6n4Sbd5Q2uUB8t9ZZYs9VY8HWSGmeMvfq2+LxsVE48H8TwXn9HIJQzcREQ07l8OqVMTPO74G23+4RNNE6uREV/WZE7VTYNVbdaULAPLt+qZUmY4FcgjOuqp7pq2+9OfO9bH6damCIGiCdUWJDcFITKm2DmpN9yCDc8pYB7y3thS65Q918biY3HJtwOPQN5xLBmu5SZC68qt/ndy6PgPy70c+LqCqLqkbx6kbrAFQtk4DoJlqrlTgM14Y0gZ1bzAKmzK9PNlAS0QydWuCfbfxGvJ8VLo9/cmGcerp5YNp3DecZqimzM8/rgq/+9ICzf3RWBy+xFZvkyocEAQB/3P9abhyTj36wlGEIjEEI3EEIzEEozEEwnHERTGlw7sgJGb4AJDng/eFoujpi6C7L4ye/rDyX7lB2pGeQOIiS49mTJUlyXXqX/7tetjM8gWg5IWhDl8I3//7dpTZLSi1W1DukP7I0+PlqrjLYUWJzTzgreAov5Jb0mXe8k3ZeUHeq92gkVohpngD8vpxbcDvVi2LKdRzh2NxxONizkuTxpKR/a8nERGNC/qAfM3pDTjruCrUq7qqyyZXlWBHi1ezRZBacj34wLYMMwp+5Zop4hkaqWXoUC09Vj+93LjabPS19nkssJlNSuge6vTygYaobGvgsz3vMU9Q+QDmC0WVKu7AA3z6Sne6vZ31jzfqdD+YmQMDGadyuzLW5IfeWFxUKvHyPtP6D+DpKuteVVf1oVS65d9Dhz+kdND2BiMoD0i3D+f08kKwmE2oLLVpGqa5nVZccZrx+vOhEkURfeEYuv1hdPhDaPVIHeRbPUG0eIM4tcGNqlIblpxShzUHuhCJicrrfnKdCzVlNtjMJoRjcfx29aGcnlPqIG9BuUPaJaI88bUc1MvsFs3sC0EAzIKAy06dhJkTy7D2QDd8wQgWnSzNTFL3YKDcJLeDc2L9oR74QlHDoCkfp96rvRBrukNR6WISAFSUWNHbH0Grqp+E02pGIBLT/PuSr+cGUqfbh2NxOEzZL4qPNQzdBpqamtDU1IRYbPwu9iciKraGCuNQ/fjN83C0N4Cp1aWG99e6pKBeUZI9IGSrdFvNJmW/39Q9w7NtX5YhsKepNhtdBNCvo7ZZYmj1IuW+XA0pOA+lSq7bNkz+IOawmnJaf685l77hnCpE65sEGTWjk9d0y+RGd0MJrEYyL4FIJS8dkLc/C+jWc2rXdCc/ILf7kiF5KMFYfqxmrXkginLH4GYkjHeCIKDMLgVduQGckc+fPRU3zZ8i7b3eH0YwGsPxE8thNgn4w+0LsPFQD/yhqPQnGIUvKH0tz3CQ9neOIBoXEYuL6OlPdp/P1Xt7O/HcV87Gl59dh75wDOu/txh/23gE//vGLvzx9rNxQm05HnptJ8LROCaWOzDRZceEMjsmVThxWoN7XFYu01FXsAGpF4A/nDo7S77oltyrPZpSkc7HGmj531xBAOrdTvT2R5TlKRaTgFqXHQe7+jUX8vL13EDqxcNgJPX/T8cDhm4DS5cuxdKlS+H1euF2u4s9HCIiUplSXZLxA+zXLpqBKVUl+PS8xqznyrbtFyAFkf5wLHOlO0OHaiC1kp/usU6rGRaTgGhcVAKQfs23uuo0uOnlmav7GR87pEq3dtuwTPtYZ+O0mmE1S3tvy+OSxyM3CdJ0h9aFdLcuiCtruvMcKtM2+8vw2gmq7c/0YqoF/eoqlDzNXe4DMFjy71e/1lxZ0z3KK90jmcn0/7d353FSlOe+wH/VXb1OL7PvMyyCoGzDOk5wI4yCGgOaGIMcFfVoTPDERA+JxmPwZMOrOV6iEo9Xr5qbnCsaj2A+iXrlogPoQVRkFR3BgAzIMGwzPVvPdE+/54/uqq6qru5pZhhm+30/Hz4O1dVVbzc1bT/1PO/zSvC7bepyeIqZI7MxU9PvIhkhBNpDXer8fmUOezxID6ElGEYgGEZXRKjTFo43d+LNT+pRHwhGnx8LBI+3dODdfccRDEXw8Zen8OWJVvzp/YOm5/7exaPxk/nj8d3/tRn5PidW3TAN/3/PUfzx/S9hl6M3Lt12Ofbf6M8uW7Tq4PLzC+GyW9VpM36XTZ3XPlgpn3F5Xkd8vnZ7KDHo1mTEgehUFu2UFeDMlHgr4/E4ZPVmtDI9RTv9ps6Q6Q6eqfLy9r6Zpz7YMOgmIqIhpcjvwj9eNDqtfTPd0RJMIUTSzLjS3ThVIzWzsuRUjdT0ndrjz5UkCT6XDSdbO9WALcNuVRuo+Vw2dc5nTwOsdG40JJNqTfF0z6s26OpF46/oXHcbTsS+oPpdNt37pCu3dibO6U5aXn6G5ywnndOd4jwehwy7HG88d7rn6818XuNSbED0JkZDIBg7Pr82DlSSJMUCWxmFJtNyktl7tBlvflKv+50BEpvpKcYXejFrVDYaAh3Y29CML461Ys+RAL5qbMeHB6Lz1VdeH8Hv1u/FrsNN3Z7/3svOxQ2V5Zjz2xrNig4yMmPd32+dPRILKkrw151f4Y1d9WjpCMMiRW9kumxWzBiZjRsqy3GipQMfHjiF6vPyYbVI+PhgIzrCXcjzOJDrcSDT3bvfjdPRZJjaoiz/V5plvp+S6QYSmzWeiQBV2+8h3sQxvtyierPtZN9kuvsiez8Y8dOTiIiGLYdsxYu3X6D+bOac/Gh3Y6WjtEIbFMsmcx69DhmSFC0tTCwvT/5cn1OOBt2xAEgJxBvbopmSeKOlnn2J7FXgrMuS92wettpdvJfLUPlc8aDb55R179Pxlk61NFtpMKV/rmy6HNyZnrPcXbM/M+pcfufpB929Hb9yTQcNX4pTrTlOg5u2v0BjezzLGgjGm3ppy4NnjszGLxZMBACs23MUt/+fjxCINadTKGXyQLTyKCfDjrbOrtifMNo6u/DJVwF8eiSAulNtqK1v1q8jHcvIHzzZhife3ocFFSW4/z936brPK17ddhjzJhTg4Tc+w5+3HsKqG6bB65Rx03Mf6PZz2iwYmZOBB646DxeNzcN7+47jwIlWjM71oHJU9hktj9d+tvmcMo41d5iu1a0EozkeuzqvWslAZ9itaO3sOiOZbt1NAKc+q61dySFxTveZyXT3VXO4wYZBNxERDWuTSlNPI3rk21Nw15yxOL/Yp9t+boEXF47JxQTDdoXFEp3P2RwMw5GkvDxVx3TjuuWNbSH4XDLsVinpc9PRXYY+5XO15eVpzJk3e25io7OefRUxW2NdeZ+0mVqvIatts0pw2ayG7uXxdbrPpGQ3NczW7lafo5nL/5VmDnda5+vl+Lu7pjine+hR/s27IkLXMyBaph7rvxAMqzf49H0n4isGGNd8VgKtb08v1XWVV/zx/S/x4NrdCLTHA/ap5Zl45qYZaGwLYdfhRvz4pR1obAuhI9ylBty/WjgRdqsFwXAXHn7jM7R1duFUW6caMB461aauAuC2R6frBIJhBEMRfFbfjD+9/yUmFPtx83MfIBybrvHDuWNx99yxuOv/foxzC7z48WXn4qMDJ/HG7nr4nDZcPqEA5xX5cLK1EzsONcJls8LjiJbLe5wyst123c3TeBVP/Oae2VrdxmocbQ+HPK8DrSfaEm6A9YRu+cTYv99hbabbZDUF4Aw2UjNmulleTkREREYeh5wQcAPRJmt/+sdKk2fEVZRlYtvBRozI1s9BV0rZzYIy067lrnj3aDXT3cMAyNtNA7hUjDcCTofyBV1tpNbLdaXNyuSV90n5Au51yLBapIRxR7PiiY3utMfM8zrUbuIAkJ1hV+dbKh2Agej7qV1HWclQAcnfX+265UZm//7p6nWmO8W/qdUiwd2L+eI0MDlki9ohXTeXP2heXm5WKRNdXzq+T2N7SL22k1d7yAnPzXLbkRsrB1eaG0bHEf89WTSrXJ3z/eym/Th4sg1NmsA9EAypfS8WTi3Bb66ZhI5wF17+sA4PvvYJmtpDaGgOqgE3EC2x39fQgjd216Om9hh+fNm5+Je1u/FZfTMA4C87DmP9vZfitj98aLqee2mWC2/9+GK8u/c4Hli7W/3c0K6q8PuaL3CksR1LZo/CydZOvP1ZA5pilQV+d7TvhNIgEwDyvU4cONGGjtAZmNNtUl6uLHHo0/S8UG7yKZ9vZ657uXFONzPdREREdAY9v2Qm2kNd8Bq+eF4wOgdXTCzEvAmFCc8pjjXRKs6Mz8tUs59OG2yW+Dq+PeG0WdXmPj2dlw30bMkwILGR2pnI2MdLsvXdt+MZcPOsuMKskVqex4Gm9hA6Y188y7JcatBdmuVSg+6yrOgSdoqybLf6ZT1VFl9bPq6sPR8dn5wwlnT1ds51quvB38v54jQwKTegjrd06jKdDYEONejSBtRmv3dNhvWlv2ps73Y5QJ/muWZTTZTHO8MRNYj1OmVdkzVtc0bt54rdqq9ccchWlMdWuwi0hxOCQG0pfXuoS3dOIL5qwBcNLQCAsmwXQmGhdpQ/dKodfz/Wir/tOqI+L9NtQ3GmC+WxG6476hqxo64RCypK8JvXP8UrWw/p3kfj73ue1wEgmhX+80d1qK1vRo7HgetmlCLX48Duw0348kQbstw2zBqVDdlqgYi96cbfU+Mccy3Tc3sc0aD7DAT82vMrTUI5p5uIiIjOKNlqgddkvrfbLuOpf5hu+pxl88fha2NycMXE+NrB35hcjMON7fjaOTn4MhZQjs339nhcfpcNDc0dPc5WAz2ZD25opNaL7uXG8yvHiDcJatftY5YV137BV7rL67/0R+eCH2+JfokuzXZjx6FoY6jSTDd2H44G2sWZLnxaH4AQ0eZ2RX6nGnSnuqGgLR8vzXbj01jgHi8vj7/XynxPIJpx1nYx1+ptpjvleM/wGuY0cESv804cOplsHfh4kGr2uxTqEjgaiAepyk2vVMsBqp8HmoBXe4157PGeGGrTL2NvBs1nSkDTK8IuR2LjSyyF155P+/q024yZ+7bY3Grlxtir35+tBsWXPbYBe2NrbCvHuOeyc7Fk9ki47TKWzRuHqeWZ+Nmru9Ee6sLJtk4cjL0/4wu9+MbkIngcMhZOLUHt0WY0B8O4aGyuOvaDJ9uw4o3P1LEcDQTxgznnYMGq99TPgZ/MH4ebqkbiyt9twuHGdhR4HVj53amx8+7C5r+fiL0fJssnmgTieV4H9ja0qDcceyMSEWiOvZe5HgfqA0GWlxMREVH/y/U4sKCiRLfthspy3FBZDgAYlZuBdT++OOk65emYP7EQ79Q2YEKJ+Xz0ZDLsshoAZmfYT+u58bmNYd1/e95ITU742Tg3UfmibTaP3ay7vPaY0VJMGcdbOmLr28YrD7RN9ZQO+M3BMLxOGzLd8fcl1Y0J7ZhKs1xq0G3M2iuP741l2fK9DhwNBNU1vXM99nipaC/nXGtLjRPGyyZqQ5byb6vthVBnKDVXlhjT/r5qVww4pHuueZCspX4etIdNp5pYLBK8DhmBYDjhJpo67tjxG9tCakAcCIbUKThmmXNtV3ZlKoi2lB6IBrbKcoSKI41B0+y9rsQ+doxzC7zq2LxOG66ZWorf/r/PcbixXXeDQGnqBgD/cMEI/MMFIxDuikC2WvDQXz4BkNjcrL4piEOn2nU33r5oaMWerwJqMP9VUxBv7q5HV0Tgz5qMemmWCzke/ed2ltuGTMP7mq/Jsq/ddhiPrfscbrsVl59fgHsuH4cDx1vx+u4j8Dpt+No5Oeqc/daOMFw2q64pXWtnWP2syvcpQTfLy4mIiGiAkyQJYwt6nuUGgF8smAghxGmXC1ssEv7n9RUIBEPI9ThO67nKF9WTrZ3Yf7xVzSD3tCRaH0jrs8NKpk350m2XLerNAuVLsnZuu7pkmOGY2lJ0bTCtXeJHmSfZHAzHsuPprYOuDSDKNMczy8SXZbvVoFtpuKSUt5dmuXXzM3tDW2qcMF42URuyzLpX6zPdoXjAqbkOtCsG1Omy5OZBsv6csSZswZB6LScs7eeyIRAMq0G83/BZoc5F1pSzB9rjc7rNSuFbOsJojAW9ylSQQLs+s62M32qR4JQtaO3sUrcZs/faXhXahmWJr9cWDbqD4ZRVPkpDNqX6RlvmDiDhBkGqbY2xDvIjc9xYOmcMvjG5GLJVwvcuGY0Dx1vhtFmxoKIEDtmCqtE5ONLUDp/LhisnFWHt9q8QDHXh5Y/q1GD+s/pm3HnpOfjFX/fg7c8aAERv+n34QDV+9bdP8b/f3Q9JAr41rRS/vW4K3th1BH98/0sA0c9g5fUGQxF8frQZRwNBFPqcvf7/2WDBoJuIiGgY6un83PkTE+ehp0P50nuytRNzflujbu9teblDtqhfUJVjKY3MjM3o2kNd6jhsVgvcdivaOrvgiDVt8hrK57XBvC5I1mS648vwtCeUaqbq8K79Yl6aFT+eWSO1Ms3jPkPQXZbtxva6xoTn9JRSagwABT6HWjbM5cKGLiVwVHoWANCVi7d2diEUScx0K383rhhgvOllfs7oYxEBHGlq123THvvQqXY1oDd7HNBn6JvaQ7ArN9E051d+t4UADscC6NIsVzToDobV3ycgHnT7XTY16E6WvTeb1272upUbBtEAv/sqH6X65liLSdAdNMxJbzcrmY/fSBid58F1M8rUx+6/4ryE8714xwXqzweOtwKIZrqNnccD7WF8pVlLXFmecdPeYwCi7+/abYfx6Lcn47F1n6s3C0syXepr+vuxFtzz8nY1A/7ItyfjiomFWPzsFpxs7cSIHDd+vXASJAn4z62HUJrtxnc04x+sEieaEREREZ1hJZkuXD+jDOXZbngc0S+gXoeMyWWZPTqeEiikWnfcNBtukv1SvgzKVgsy7PEAXlvqrc1g6zPT8WV4tN2BtWM0H78+k609nvG5used+nmZJZnaGwC9z6Vo38PSrMRx0dCTzs0aZX6v8TpQrkXtcmOHNGtAJ+O0WdWlveKZcfNjHzqlb4yY+Li2FD6s69atcMhWtSO6cjzl+u6KCNRrxq82YtSsYW1szqiOwaS83OxGorLtVFtnvLN7qqA7NtYTLfqbXtrgXllNILquuT447u4mQCrKuTvCXQlN55raQ7rVGoDE5nThiEB7qAunYjcyvnfJaPx+8TT1uJ/VN0PbluLTIwFs/fIUdh5qwqFT7Xhv3wm8tv0r7GtoweNv78MfN395WuMfqPgJSkRERH1OkiT8j29PVv8eDHVBkpC00VJ3lHJvY/MzLbOAXN9cyYYjTUHdGPwuG1o7u+A3BNPaL8gFfqfa0EwbaGsDYosUnQOfjHI8t92qmx9vlunWBtbR8vLoF1yPQ0Z2RuJNhN7QB90ubP3yVHQ7y8uHrNO5bowrMSi/I9o5xh1qgJ76uEqjwvpA0HR/4xKACU3ADAExEM3w2tXVCBKD+GCoQz1evs8Bm1VCqEvgUGP8GNogX6miqdNkv43HBKJl4Klet1kJvzfFTQnlM0l5W8uyXWg6HIoFuMrUEhc+P9oSmyceVrcdOqWUsSvLtp1euKecO9QlcKpNP9UkaXm7SdCv7HdT1chYpjt63AZDyXxTe2L2vrG9Uz3mUKmyYaabiIiIzrro0mU9X/e5clQ2vjG5CD+Yc466zdhcrkiz7FpWLEjP1jU6i34ZVTLd0W3xoFebHVe++FmkaGdlbZM2fRl6vFGbtqGQkTZQ9xtuBGj/CwC53vi6xUpX9eg+sm6/M1NeniyjPzS++FKidG+oKOvep/vc7oIl5bo3my+u/buSGU6c8x19/ilNaXhHOKJmYpNlpeNzxOO/u9o56crP2seNzRmNY1CCaUmKvk9GxuNk2K3q3HMz2s8kIP672Kzpvq5s05aXa7eZNahLh/bcyntZFGskeaq1U21ap9w0ONHSibbYlB5l1tKx5g61IaPynimfYQnz1A3d45Vt6k2DIVJlMzReBREREQ0rTpsVT94wTbdtalkmXrrjAuxtaIHVIuGbU4rVx75/6TnI89p1a6NfOakIR5qCmDkyW902Oi8Dn9U3Y3SeJ75Gd7YLBb7ol85CnxMWi4Q8rwOn2kLI8zqQHesInJ3hgN+VmIE3oy2PNyt51z5f2ScY6oDfZUNbR3zOunG/3tIeo9Qwl5yGpnSDGtMMbqpmgd0E82ZrRqf6e6pKlnTOr/zOqUF5rAfDidZO3Txl7RJlDpuxBN58jMpzvA7Z9GZbvMlj903mAJOgOzbFJDoHPrbUYOz3s7kjrDZNU7Zpl0Y77fJyOfFmQFmWG0eagjiseZ9Ks6JLHWrn1JdkRjPtyvtlkaBOJ1Jusirz1J02C4KhSNLseU/HP1Ax6DaxatUqrFq1Cl1dw7OlPRER0WAkSRIqR+egcnROwmPTR2Rh+ogs3bZbZo/CLbNH6bY98u0pWDpnDCYU+3F+kQ+5Hgdmjc6Gz2nD7xdPQ2Es4/OrhZOwo64Rk0v9yM6wozMcweLKchT4nFhYUYzZY3JTjrUk9uW4JMtluvaxsQze54qvrd7qimfyzNYr7w19wzjtXHJ+ZRyq0r1uzALFdJsFpnPeZJnppPunGLdLM2c82fG000bCmvL4eCNGOR4oNps3FFTGoASjyYJpY9O37t5zh01fBZTnccAuW9AZjqjl9NqeC4di51d+Z5uDYbUC4HQ/F2SrBbJFUt8Tu2xR1yVXbhq47VbkxKbFHDoZv+GQnWGPNb+Ll+grTTuVYF65mVma5ca+hhbdMmpFfieONAV124bK1BZ+gppYunQpli5dikAgAL/f39/DISIiorPE45AxoTj6/367bEH1+QXqY1dOKlJ/njUqG7NGRTPkZdluLL96gvrYyu9O7fY8VaNz8PSN0zG51A+nzYrvzixDczCsrpGb5bbDIkVvJGS6443cfC4b2jo1mTpdefkZaKQWO55dtqhjUc5LQ1O6mUSzGy+pbsZ0m4nWPG5Wlm08ttmSYsmPnTgus+enbHbossFpmAKT7EaBsq53stesXVM81X4KY7ZZmVZyvKVDzarneOzqUojajuyKw+rc9NP/XHDIFoSVmw9Om6aMvs1kW/yGg7G5nfb9Mr6m0ixXPOgOxsvjjzQFY/O8e1YeP1Ax6CYiIiI6yyRJ0pW6P/ytybrHMxwyHv7WZFgkCU6bFd+cUozGthCqzslBbX0AAHB+kRc5sdJ2r1Pu1Rx5Rbx7umH5syHyxZcSGYMar0NW5+0qjcbM9ku2TX2su/JyTcDrMSnLPt3Mt5bZ9Wq23Fd343caMs7dlbgnG1OyJnHJGM8bbdgo43hLh7qkX3T80aUQlWXXcjwONRBPZ730ZBw2q5rx92v6SNRpOs0nZO9d8UBcO29ee0wtdf65pulbaZYLHxyIZuqV8nIG3URERETUZ7Rr0y6ZPQpLYqXwJZkubL7/6yj0OSFJEn65YALyfc5khzkt8TnlhiZtQ6TEkxJpg19HrJRYCbpLMl04cCL5utva60Lp6K84nUx3OkFywpJiKQJX02W7EpYkk1Ne19FMtz47212QnWxMZp3UU0nIdDsTbxAomeWjgQ61y7k2EFe7qffgd9fYXFLtvn4ysQmddom4eGO6xCx74jz1aFa+pSOsrhGvzknXdGQfKlNb2L2ciIiIaJAp8rvUuZI3Vo3UZc17Y2y+FwBwboEXTlu0xNwhW1Dgc3TzTBqsjD0FvLpmevo14o20QWj0JpD5cc3o17Tvfr64MeB12aywWc1XCEin6Zs2M5tsfN3OK0+ytnh34zndRmra0m3tuRJvAiTeSOhJlYou6NYE/MrNGO027ZJvxqXRUpeXx68tZU58qTInvSOsLlc2VKpshsatAyIiIiLqtXGFXmxcNgf5PgckScLL36tCW2dXwvrMNHToKxpkXZCjZCOBJNloTdDpd9kQCIZ03cHTPq9J8Ntd4zRJkuBzRruPA/qyeNP555rxu2NLdqXuvp44ZSOhFD/NAPd05qMDSDiv2Q2AdLf1qLxcc36/ydx37Xx4ocmyK69TybLryssNryk7ww633Yq2zi61e7xuTno3zekGG2a6iYiIiEhVnuNW55SOzM3A+cW+fh4R9SW7bIEr9u9tDLB0me5uAmNt0KX8PRVjwJ7qcatFgtue2LNAG5CVarrtd1eurvys3U8yJM3NMuHGIN1qkXQN4JIFiIkZ89R5T2WpMu15zdYIN27zGvZLtm54d7Tn97nk9IJ70zFq53SbvSZ99/jc2Jx0AGnfvBksGHQTEREREQ1jagM9QzClW6vddJ60Plut3cfTTWDZXc8AYwZeMkbF0AevZd2sK28W5Gv3KzT0RTDeRNA+T39c/TjNZNit0PaJO53u5ZIUbZSofY5skeCyWXXnVpZJ0+5n1qAuHdqu7cZVEqLbEgNxs+Bc3y/AkL13J97U8Jvc6Bgq5eUMuomIiIiIhjElqNIGWA7N+syAefBjnJetBExehwxrN8Ge2fr0Wm67VT1G0qW4ejj/PN6lPx7gFWe69HPSTZuXJQbVXs0xkq1bLklSt69XSxugKoGzsfGcUl6v3WY8dk8DVm1WWumcrmU2x9yfZJvZMQHz+edmAb6XjdSIiIiIiGiwi3ett+mz3s7UgaJDtsButcSf60wM/Lo7p/FnhSRJpoGkVrKsfLrl5drnZ7pshlJxGR67rAvEzXob+FyJxzUd62msBqAr79bcEDGe0/xGQvrnSXr+JN3LtdsSAnGnSTm+bk53/JgWCciw6zPjNqsEp82S8Bzj8mmDFYNuIiIiIqJhzKcGt/HsYzpztKMZ3MTS9HSCbm2WOVlZtrI9aVdwzfYSXXl56kZqajBvCGSVTLXTZoFDtsKimbOdLHuvD3yTv+7Tme+uDVD9mn8b9TzK+6LbZrJfN+uBJz9/d+XlJttMyvH13cutun0tFkn37x7P3qee6z9YMegmIiIiIhrGcj12AEBOhgNZ7ujPmQmZ7mSBsRLAyppgtvtgz9tNFl27PXl5eTwgzs6wJ4xJf77EhmfGed6psspJx2hS4p1qrMafzditFjXDbprBNrlp4Dd5r3pcXm4I+p2x+eLababN1UwCcbNjmjWyM902hILuoVEkT0REREREPfL9S8eg0OfEtdNKIFstuHZaCa6eXAyvU0ZplgvBUAQ5GeZrtXs1QamvPdpxOp1gT+ma3h7qSh5Um2RvzR/vvhTeZrWoS1SZZdC1c4yNWfFDp9qTzi02yzanGmuy8WlJkgSHbEEwFEkZjJrNEz8j5eWG7uXKsY63dKjblEC8M7Y8mHmX8/h74zQ7pmZ/r8lrGkqZbgbdRERERETD2KjcDNxz+Tj17499p0L9+Y27L0IkAl2mU2vBlGI0t4dwwegcuO2NAKLrvafD77KhPdSVItOdurxcCcq8TrnbJciU47R1xs/ntFnhkC3oCEd0S4SZZWDTyXSnymAr+1kkwGPvPgRzyFYEQxHTee2mGXlnYiDb00yxcZ3u6LHkeNCtOb+yze+yqXP8O7siCeMzPaZZIziT1zQUDJ1XQkREREREZ5RZ8zCtWy8chVsvHAUAKPI7UfPPl6JMs2Z26ueOxOYvTmByqd/08ZLM6Dzt4kyX6eNKd/V8nzM2JxgQInmw6XfZUB8IJgSmx5o7dNly3Xxzk0DceEwg2gjMlaLpl1oK77SltYyXUo4dz2An3lQwKyVPt9w9nXNrj6c7l9s8EFfm+B9v6dSNPdkxu52nzkw3ERERERFRnCRJGJmbkfb+d1x8Du64+Jykj//g0jE4r8iH+RMLTR+fMy4f918xHhefmwe3XcZP549HV0QkDTaLM52oPdqsBvNANNg71tyhaxzXXVZZS1vWbbaWuMKsIVoqSol3PJufmFE3C1DNAtnTpQ2QvYZSfEmTqVe2WS0S3HarOo7jLZ2wGzqPO2z65mza/+rGfwZuGgxEDLqJiIiIiGjAycqw49pppUkft8sWfO+SeNB+5yXJA3gA+OXCifj4YCOqRueo2y4dl48TrYcwudSPo4EgAGCEJlOfFWvQlpVkDW6zsm7T/bppCmeklGMrx9fOgVcCU48jMeg+E43IlADZ45AhW/UZd29s3XDjOZUbDsluUuias7mT39wwK+0fChh0ExERERHRkFea5UZplr70/cFvnI+fXXkerBYJ188sQ1mWG5Wjs9XHvzuzDCdbO7Gostz0mJNK/fA4ZFygeY6Z/FgpfJ7HvCGdkbG8HIjPgVcCU9lqgccho6UjbBqI97a83GxZN787MRPtM+kMb1zHW19enliyb1ZlwEw3ERERERHREKCsv+2QrZgzPl/32Og8D3573ZSkzy3yu7D1wWrYralXYp4zPh8PXHkeLhmXl9aYivxOfPJVACNy9Fn3+kDQsDxaLOiOBbm6QLyXme7uu6ObNG9LkvmXJEntdm56LNOl0YZOqDp0XgkREREREdFZpu3MnWqf2y8enfYxV1w7GUvqmzGtPEvd9pP547Dp8+OYNSqeVV98wQhsqD2GqWXx/cYXerHzcBNG5qQ/v14/VvMsO2A+D7u7hm7a43aGI6bz282bqzHTPWjU1dXhxhtvRENDA2RZxoMPPojrrruuv4dFRERERERkKs/rULuzK+aMy8eccfpM/NI5Y7B0zhjdtj/eVonmYCjh+emqKMuExyHjojG56jal+VxJVrwJXbqBuMIhW9GM1KXwbKQ2SMmyjJUrV6KiogL19fWYPn06rrzySmRk9OzODxERERER0UDlslvhsneffU/m3AIvdiy/XC27B4D5EwvxxKKpuEDThG7ehELU1Dbg+pllmud6AABj8z0Jx/U5o0uMKeXxZqXwXpP54UPBkA+6i4qKUFRUBAAoLCxEbm4uTp48yaCbiIiIiIjIhNWwlrjNasHVU4p120blZmD1HVW6bQsrSjCpxI9RuYlB97984zxsr2vCpJL4uuxzz8vHxwdPqUG6bLWg0OdEQ3MQBT7nmXo5/S71jP+zYOPGjbj66qtRXFwMSZKwdu3ahH1WrVqFkSNHwul0orKyEh988EGPzrV161Z0dXWhrKys+52JiIiIiIgobZIkYUy+NyFoB4Cvjy/APZedqy45BgC/++5UbPjnOcjQlJo/e/MMvHDLrB6Xxw9E/Z7pbm1txZQpU3Drrbfi2muvTXj8pZdewj333IN///d/R2VlJVauXIl58+ahtrYW+fnROQ0VFRUIh8MJz33rrbdQXBy9I3Py5EncdNNNeOaZZ/r2BREREREREVFaLIYAfaImEz5USEII0d+DUEiShDVr1mDhwoXqtsrKSsycORNPPvkkACASiaCsrAz/9E//hPvuuy+t43Z0dOCyyy7D7bffjhtvvDHlfh0dHerfA4EAysrK0NTUBJ/P17MXRURERERERENOIBCA3+/vNl7s9/LyVDo7O7F161ZUV1er2ywWC6qrq7F58+a0jiGEwJIlS/D1r389ZcANACtWrIDf71f/sAydiIiIiIiIemNAB93Hjx9HV1cXCgoKdNsLCgpQX1+f1jHee+89vPTSS1i7di0qKipQUVGBXbt2me57//33o6mpSf1TV1fX69dAREREREREw1e/z+nuaxdeeCEikUha+zocDjgcQ2fCPhEREREREfWvAZ3pzs3NhdVqxdGjR3Xbjx49isLCwn4aFREREREREVF6BnSm2263Y/r06Vi/fr3aXC0SiWD9+vW46667+uy8q1atwqpVq9SO6IFAoM/ORURERERERIOPEid215u837uXt7S0YN++fQCAqVOn4rHHHsOcOXOQnZ2N8vJyvPTSS7j55pvx9NNPY9asWVi5ciVefvllfPbZZwlzvc+0Q4cOsZkaERERERERJVVXV4fS0tKkj/d70F1TU4M5c+YkbL/55pvxwgsvAACefPJJPProo6ivr0dFRQUef/xxVFZW9vnYIpEIvvrqK3i9XkhS4gLv/U1Z0qyuro5LmtGAwGuSBiJelzTQ8JqkgYbXJA1Eg+G6FEKgubkZxcXFsFiSz9zu96Cbei7ddeGIzhZekzQQ8bqkgYbXJA00vCZpIBpK1+WAbqRGRERERERENJgx6CYiIiIiIiLqIwy6BzGHw4Hly5dzbXEaMHhN0kDE65IGGl6TNNDwmqSBaChdl5zTTURERERERNRHmOkmIiIiIiIi6iMMuomIiIiIiIj6CINuIiIiIiIioj7CoHsQW7VqFUaOHAmn04nKykp88MEH/T0kGgI2btyIq6++GsXFxZAkCWvXrtU9LoTAz3/+cxQVFcHlcqG6uhp79+7V7XPy5EksXrwYPp8PmZmZuO2229DS0qLbZ+fOnbjooovgdDpRVlaGRx55pK9fGg1SK1aswMyZM+H1epGfn4+FCxeitrZWt08wGMTSpUuRk5MDj8eDb33rWzh69Khun4MHD+Kqq66C2+1Gfn4+li1bhnA4rNunpqYG06ZNg8PhwJgxY/DCCy/09cujQeqpp57C5MmT4fP54PP5UFVVhTfeeEN9nNck9beHH34YkiThRz/6kbqN1yWdTQ899BAkSdL9GT9+vPr4sLoeBQ1Kq1evFna7XTz33HPik08+EbfffrvIzMwUR48e7e+h0SD3+uuviwceeEC8+uqrAoBYs2aN7vGHH35Y+P1+sXbtWrFjxw7xzW9+U4waNUq0t7er+8yfP19MmTJFvP/++2LTpk1izJgxYtGiRerjTU1NoqCgQCxevFjs3r1bvPjii8Llcomnn376bL1MGkTmzZsnnn/+ebF7926xfft2ceWVV4ry8nLR0tKi7nPnnXeKsrIysX79evHRRx+JCy64QHzta19THw+Hw2LixImiurpabNu2Tbz++usiNzdX3H///eo+f//734Xb7Rb33HOP2LNnj3jiiSeE1WoVb7755ll9vTQ4/OUvfxF/+9vfxOeffy5qa2vFz372M2Gz2cTu3buFELwmqX998MEHYuTIkWLy5Mni7rvvVrfzuqSzafny5WLChAniyJEj6p9jx46pjw+n65FB9yA1a9YssXTpUvXvXV1dori4WKxYsaIfR0VDjTHojkQiorCwUDz66KPqtsbGRuFwOMSLL74ohBBiz549AoD48MMP1X3eeOMNIUmSOHz4sBBCiN///vciKytLdHR0qPv89Kc/FePGjevjV0RDQUNDgwAgNmzYIISIXoM2m038+c9/Vvf59NNPBQCxefNmIUT0ZpLFYhH19fXqPk899ZTw+XzqdfiTn/xETJgwQXeu66+/XsybN6+vXxINEVlZWeLZZ5/lNUn9qrm5WYwdO1asW7dOXHLJJWrQzeuSzrbly5eLKVOmmD423K5HlpcPQp2dndi6dSuqq6vVbRaLBdXV1di8eXM/joyGuv3796O+vl537fn9flRWVqrX3ubNm5GZmYkZM2ao+1RXV8NisWDLli3qPhdffDHsdru6z7x581BbW4tTp06dpVdDg1VTUxMAIDs7GwCwdetWhEIh3XU5fvx4lJeX667LSZMmoaCgQN1n3rx5CAQC+OSTT9R9tMdQ9uHnKnWnq6sLq1evRmtrK6qqqnhNUr9aunQprrrqqoRrh9cl9Ye9e/eiuLgYo0ePxuLFi3Hw4EEAw+96ZNA9CB0/fhxdXV26CxAACgoKUF9f30+jouFAub5SXXv19fXIz8/XPS7LMrKzs3X7mB1Dew4iM5FIBD/60Y8we/ZsTJw4EUD0mrHb7cjMzNTta7wuu7vmku0TCATQ3t7eFy+HBrldu3bB4/HA4XDgzjvvxJo1a3D++efzmqR+s3r1anz88cdYsWJFwmO8Lulsq6ysxAsvvIA333wTTz31FPbv34+LLroIzc3Nw+56lPt7AEREROlaunQpdu/ejXfffbe/h0KEcePGYfv27WhqasIrr7yCm2++GRs2bOjvYdEwVVdXh7vvvhvr1q2D0+ns7+EQ4YorrlB/njx5MiorKzFixAi8/PLLcLlc/Tiys4+Z7kEoNzcXVqs1obvf0aNHUVhY2E+jouFAub5SXXuFhYVoaGjQPR4Oh3Hy5EndPmbH0J6DyOiuu+7CX//6V7zzzjsoLS1VtxcWFqKzsxONjY26/Y3XZXfXXLJ9fD7fsPtyQOmx2+0YM2YMpk+fjhUrVmDKlCn43e9+x2uS+sXWrVvR0NCAadOmQZZlyLKMDRs24PHHH4csyygoKOB1Sf0qMzMT5557Lvbt2zfsPicZdA9Cdrsd06dPx/r169VtkUgE69evR1VVVT+OjIa6UaNGobCwUHftBQIBbNmyRb32qqqq0NjYiK1bt6r7vP3224hEIqisrFT32bhxI0KhkLrPunXrMG7cOGRlZZ2lV0ODhRACd911F9asWYO3334bo0aN0j0+ffp02Gw23XVZW1uLgwcP6q7LXbt26W4IrVu3Dj6fD+eff766j/YYyj78XKV0RSIRdHR08JqkfjF37lzs2rUL27dvV//MmDEDixcvVn/mdUn9qaWlBV988QWKioqG3+dkf3dyo55ZvXq1cDgc4oUXXhB79uwRd9xxh8jMzNR19yPqiebmZrFt2zaxbds2AUA89thjYtu2beLLL78UQkSXDMvMzBSvvfaa2Llzp1iwYIHpkmFTp04VW7ZsEe+++64YO3asbsmwxsZGUVBQIG688Uaxe/dusXr1auF2u7lkGJn6/ve/L/x+v6ipqdEtO9LW1qbuc+edd4ry8nLx9ttvi48++khUVVWJqqoq9XFl2ZHLL79cbN++Xbz55psiLy/PdNmRZcuWiU8//VSsWrVqQC47QgPDfffdJzZs2CD2798vdu7cKe677z4hSZJ46623hBC8Jmlg0HYvF4LXJZ1d9957r6ipqRH79+8X7733nqiurha5ubmioaFBCDG8rkcG3YPYE088IcrLy4XdbhezZs0S77//fn8PiYaAd955RwBI+HPzzTcLIaLLhj344IOioKBAOBwOMXfuXFFbW6s7xokTJ8SiRYuEx+MRPp9P3HLLLaK5uVm3z44dO8SFF14oHA6HKCkpEQ8//PDZeok0yJhdjwDE888/r+7T3t4ufvCDH4isrCzhdrvFNddcI44cOaI7zoEDB8QVV1whXC6XyM3NFffee68IhUK6fd555x1RUVEh7Ha7GD16tO4cRFq33nqrGDFihLDb7SIvL0/MnTtXDbiF4DVJA4Mx6OZ1SWfT9ddfL4qKioTdbhclJSXi+uuvF/v27VMfH07XoySEEP2TYyciIiIiIiIa2jinm4iIiIiIiKiPMOgmIiIiIiIi6iMMuomIiIiIiIj6CINuIiIiIiIioj7CoJuIiIiIiIiojzDoJiIiIiIiIuojDLqJiIiIiIiI+giDbiIiIiIiIqI+wqCbiIiIiIiIqI8w6CYiIiKdJUuWYOHChf09DCIioiGBQTcRERERERFRH2HQTURENEy98sormDRpElwuF3JyclBdXY1ly5bhD3/4A1577TVIkgRJklBTUwMAqKurw3e+8x1kZmYiOzsbCxYswIEDB9TjKRnyf/3Xf0VeXh58Ph/uvPNOdHZ29s8LJCIiGgDk/h4AERERnX1HjhzBokWL8Mgjj+Caa65Bc3MzNm3ahJtuugkHDx5EIBDA888/DwDIzs5GKBTCvHnzUFVVhU2bNkGWZfzqV7/C/PnzsXPnTtjtdgDA+vXr4XQ6UVNTgwMHDuCWW25BTk4Ofv3rX/fnyyUiIuo3DLqJiIiGoSNHjiAcDuPaa6/FiBEjAACTJk0CALhcLnR0dKCwsFDd/09/+hMikQieffZZSJIEAHj++eeRmZmJmpoaXH755QAAu92O5557Dm63GxMmTMAvfvELLFu2DL/85S9hsbDAjoiIhh/+34+IiGgYmjJlCubOnYtJkybhuuuuwzPPPINTp04l3X/Hjh3Yt28fvF4vPB4PPB4PsrOzEQwG8cUXX+iO63a71b9XVVWhpaUFdXV1ffp6iIiIBipmuomIiIYhq9WKdevW4b/+67/w1ltv4YknnsADDzyALVu2mO7f0tKC6dOn4z/+4z8SHsvLy+vr4RIREQ1aDLqJiIiGKUmSMHv2bMyePRs///nPMWLECKxZswZ2ux1dXV26fadNm4aXXnoJ+fn58Pl8SY+5Y8cOtLe3w+VyAQDef/99eDwelJWV9elrISIiGqhYXk5ERDQMbdmyBb/5zW/w0Ucf4eDBg3j11Vdx7NgxnHfeeRg5ciR27tyJ2tpaHD9+HKFQCIsXL0Zubi4WLFiATZs2Yf/+/aipqcEPf/hDHDp0SD1uZ2cnbrvtNuzZswevv/46li9fjrvuuovzuYmIaNhippuIiGgY8vl82LhxI1auXIlAIIARI0bg3/7t33DFFVdgxowZqKmpwYwZM9DS0oJ33nkHl156KTZu3Iif/vSnuPbaa9Hc3IySkhLMnTtXl/meO3cuxo4di4svvhgdHR1YtGgRHnroof57oURERP1MEkKI/h4EERERDX5LlixBY2Mj1q5d299DISIiGjBY60VERERERETURxh0ExEREREREfURlpcTERERERER9RFmuomIiIiIiIj6CINuIiIiIiIioj7CoJuIiIiIiIiojzDoJiIiIiIiIuojDLqJiIiIiIiI+giDbiIiIiIiIqI+wqCbiIiIiIiIqI8w6CYiIiIiIiLqIwy6iYiIiIiIiPrIfwOJSDlOM51AHQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "fig, ax = plt.subplots(2, 1, figsize=(10, 5))\n", + "for i, m in enumerate([\"loss\", \"error\"]):\n", + " sns.lineplot(\n", + " model.convergence_trajectory_df,\n", + " x=\"step\",\n", + " y=m,\n", + " ax=ax[i],\n", + " # yscale=\"log\",\n", + " )\n", + " ax[i].set_yscale(\"log\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "512fa68a", + "metadata": {}, + "source": [ + "Here, we can see the model did not converge, but the model loss seems to be roughly unchanged at this point and is good enough for the purposes of this example." + ] + }, + { + "cell_type": "markdown", + "id": "d33aeb10", + "metadata": {}, + "source": [ + "\n", + "The `Model` object allows provides many of the same properties, like mutations and variants dataframes, but add additional features relevant to the parameters of this model. `Model.get_mutations_df` returns the associated data object's mutations_df as seen above, along with the $\\beta$ and $S_{m,h}$ parameter's associated with each mutation. " + ] + }, + { + "cell_type": "code", + "execution_count": 16, "id": "fa1f0e0e-a060-4393-9bf0-27f3bdd4283c", "metadata": {}, "outputs": [ @@ -1013,22 +1132,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "Help on function get_mutations_df in module multidms.model:\n", + "Help on _lru_cache_wrapper in module multidms.model:\n", "\n", - "get_mutations_df(self, phenotype_as_effect=True, times_seen_threshold=0, return_split=True)\n", - " Mutation attributes and phenotypic effects.\n", + "get_mutations_df(self, times_seen_threshold=0, phenotype_as_effect=True, return_split=True)\n", + " Mutation attributes and phenotypic effects\n", + " based on the current state of the model.\n", " \n", " Parameters\n", " ----------\n", - " phenotype_as_effect : bool, optional\n", - " if True, phenotypes (both latent, and func_score)\n", - " are calculated as the _difference_ between predicted\n", - " phenotype of a given variant and the respective experimental\n", - " wildtype prediction. Otherwise, report the unmodified\n", - " model prediction.\n", " times_seen_threshold : int, optional\n", " Only report mutations that have been seen at least\n", " this many times in each condition. Defaults to 0.\n", + " phenotype_as_effect : bool, optional\n", + " if True, phenotypes are reported as the difference\n", + " from the conditional wildtype prediction. Otherwise,\n", + " report the unmodified model prediction.\n", " return_split : bool, optional\n", " If True, return the split mutations as separate columns:\n", " 'wts', 'sites', and 'muts'.\n", @@ -1040,9 +1158,13 @@ " A copy of the mutations data, `self.data.mutations_df`,\n", " with the mutations column set as the index, and columns\n", " with the mutational attributes (e.g. betas, shifts) and\n", - " conditional phenotypes (e.g. func_scores) added.\n", - " Phenotypes are predicted\n", - " based on the current state of the model.\n", + " conditional functional score effect (e.g. ) added.\n", + " \n", + " The columns are ordered as follows:\n", + " - beta_a, beta_b, ... : the latent effect of the mutation\n", + " - shift_b, shift_c, ... : the conditional shift of the mutation\n", + " - predicted_func_score_a, predicted_func_score_b, ... : the\n", + " predicted functional score of the mutation.\n", "\n" ] } @@ -1053,7 +1175,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "id": "e72a9a79", "metadata": {}, "outputs": [ @@ -1078,15 +1200,16 @@ " \n", " \n", " \n", - " beta\n", - " shift_Omicron_BA1-2\n", - " predicted_func_score_Delta-2\n", - " predicted_func_score_Omicron_BA1-2\n", - " times_seen_Delta-2\n", - " times_seen_Omicron_BA1-2\n", " wts\n", " sites\n", " muts\n", + " times_seen_Delta-2\n", + " times_seen_Omicron_BA1-2\n", + " beta_Delta-2\n", + " beta_Omicron_BA1-2\n", + " shift_Omicron_BA1-2\n", + " predicted_func_score_Delta-2\n", + " predicted_func_score_Omicron_BA1-2\n", " \n", " \n", " mutation\n", @@ -1099,100 +1222,106 @@ " \n", " \n", " \n", + " \n", " \n", " \n", " \n", " \n", " M1I\n", - " -4.897398\n", - " -0.009559\n", - " -3.227453\n", - " -3.229870\n", - " 0.0\n", - " 1.0\n", " M\n", " 1\n", " I\n", + " 0\n", + " 1\n", + " -0.670376\n", + " -0.670376\n", + " 0.000000\n", + " -1.924031\n", + " -2.092655\n", " \n", " \n", " M1-\n", - " -15.076238\n", - " 0.000000\n", - " -3.498683\n", - " -3.498683\n", - " 1.0\n", - " 0.0\n", " M\n", " 1\n", " -\n", + " 1\n", + " 0\n", + " -1.210833\n", + " -1.217279\n", + " -0.006446\n", + " -3.518891\n", + " -3.696349\n", " \n", " \n", " F2L\n", - " 6.499686\n", - " -0.002973\n", - " 0.760441\n", - " 0.760439\n", - " 1.0\n", - " 1.0\n", " F\n", " 2\n", " L\n", + " 1\n", + " 1\n", + " 0.376333\n", + " 0.376333\n", + " 0.000000\n", + " 0.886560\n", + " 0.760452\n", " \n", " \n", " F2Y\n", - " 7.830030\n", - " 0.000000\n", - " 0.760958\n", - " 0.760958\n", - " 1.0\n", - " 0.0\n", " F\n", " 2\n", " Y\n", + " 1\n", + " 0\n", + " 0.624053\n", + " 0.624053\n", + " 0.000000\n", + " 1.397594\n", + " 1.287470\n", " \n", " \n", " V3F\n", - " 0.289656\n", - " -1.952068\n", - " 0.437663\n", - " -0.800541\n", - " 1.0\n", - " 4.0\n", " V\n", " 3\n", " F\n", + " 1\n", + " 4\n", + " 0.061322\n", + " -0.366089\n", + " -0.427411\n", + " 0.137714\n", + " -1.191158\n", " \n", " \n", "\n", "" ], "text/plain": [ - " beta shift_Omicron_BA1-2 predicted_func_score_Delta-2 \\\n", + " wts sites muts times_seen_Delta-2 times_seen_Omicron_BA1-2 \\\n", "mutation \n", - "M1I -4.897398 -0.009559 -3.227453 \n", - "M1- -15.076238 0.000000 -3.498683 \n", - "F2L 6.499686 -0.002973 0.760441 \n", - "F2Y 7.830030 0.000000 0.760958 \n", - "V3F 0.289656 -1.952068 0.437663 \n", - "\n", - " predicted_func_score_Omicron_BA1-2 times_seen_Delta-2 \\\n", - "mutation \n", - "M1I -3.229870 0.0 \n", - "M1- -3.498683 1.0 \n", - "F2L 0.760439 1.0 \n", - "F2Y 0.760958 1.0 \n", - "V3F -0.800541 1.0 \n", - "\n", - " times_seen_Omicron_BA1-2 wts sites muts \n", - "mutation \n", - "M1I 1.0 M 1 I \n", - "M1- 0.0 M 1 - \n", - "F2L 1.0 F 2 L \n", - "F2Y 0.0 F 2 Y \n", - "V3F 4.0 V 3 F " + "M1I M 1 I 0 1 \n", + "M1- M 1 - 1 0 \n", + "F2L F 2 L 1 1 \n", + "F2Y F 2 Y 1 0 \n", + "V3F V 3 F 1 4 \n", + "\n", + " beta_Delta-2 beta_Omicron_BA1-2 shift_Omicron_BA1-2 \\\n", + "mutation \n", + "M1I -0.670376 -0.670376 0.000000 \n", + "M1- -1.210833 -1.217279 -0.006446 \n", + "F2L 0.376333 0.376333 0.000000 \n", + "F2Y 0.624053 0.624053 0.000000 \n", + "V3F 0.061322 -0.366089 -0.427411 \n", + "\n", + " predicted_func_score_Delta-2 predicted_func_score_Omicron_BA1-2 \n", + "mutation \n", + "M1I -1.924031 -2.092655 \n", + "M1- -3.518891 -3.696349 \n", + "F2L 0.886560 0.760452 \n", + "F2Y 1.397594 1.287470 \n", + "V3F 0.137714 -1.191158 " ] }, - "execution_count": 16, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -1212,7 +1341,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "id": "996c3954-3429-4f9e-92f8-927bbc211f4f", "metadata": {}, "outputs": [ @@ -1220,7 +1349,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Help on function get_variants_df in module multidms.model:\n", + "Help on _lru_cache_wrapper in module multidms.model:\n", "\n", "get_variants_df(self, phenotype_as_effect=True)\n", " Training data with model predictions for latent,\n", @@ -1251,7 +1380,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "id": "c9101e39", "metadata": {}, "outputs": [ @@ -1293,8 +1422,8 @@ " 599\n", " -0.15963\n", " \n", - " 2.209213\n", - " 0.339735\n", + " 0.000000\n", + " -3.712308e-16\n", " \n", " \n", " 1\n", @@ -1303,8 +1432,8 @@ " 1\n", " -1.29760\n", " A1016S\n", - " 0.090485\n", - " -1.272478\n", + " -0.456546\n", + " -1.270584e+00\n", " \n", " \n", " 2\n", @@ -1313,8 +1442,8 @@ " 1\n", " -0.88240\n", " A1016T\n", - " 0.598338\n", - " -0.749924\n", + " -0.213680\n", + " -5.759269e-01\n", " \n", " \n", " 3\n", @@ -1323,8 +1452,8 @@ " 1\n", " -0.03900\n", " A1016T K1191L\n", - " 1.250767\n", - " -0.186957\n", + " -0.126598\n", + " -3.365835e-01\n", " \n", " \n", " 4\n", @@ -1333,8 +1462,8 @@ " 1\n", " 0.50800\n", " A1020C\n", - " 3.341482\n", - " 0.615564\n", + " 0.261282\n", + " 6.454972e-01\n", " \n", " \n", "\n", @@ -1349,20 +1478,41 @@ "4 Delta-2 A1020C 1 0.50800 A1020C \n", "\n", " predicted_latent predicted_func_score \n", - "0 2.209213 0.339735 \n", - "1 0.090485 -1.272478 \n", - "2 0.598338 -0.749924 \n", - "3 1.250767 -0.186957 \n", - "4 3.341482 0.615564 " + "0 0.000000 -3.712308e-16 \n", + "1 -0.456546 -1.270584e+00 \n", + "2 -0.213680 -5.759269e-01 \n", + "3 -0.126598 -3.365835e-01 \n", + "4 0.261282 6.454972e-01 " ] }, - "execution_count": 18, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "model.get_variants_df(phenotype_as_effect=False).head()" + "model.get_variants_df().head()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "796d537a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ProxGradState(iter_num=Array(5000, dtype=int64, weak_type=True), stepsize=Array(0.5, dtype=float64), error=Array(0.02185074, dtype=float64), aux=None, velocity={'beta': {'Delta-2': Array([-0.67035874, -1.21096323, 0.37641966, ..., -0.63904707,\n", + " 0.09749028, 0.60156794], dtype=float64), 'Omicron_BA1-2': Array([-0.67035874, -1.21740883, 0.37641966, ..., 0.32806356,\n", + " -0.56374356, 0.60156794], dtype=float64)}, 'beta0': {'Delta-2': Array([0.75801103], dtype=float64), 'Omicron_BA1-2': Array([0.70161721], dtype=float64)}, 'shift': {'Delta-2': Array([0., 0., 0., ..., 0., 0., 0.], dtype=float64), 'Omicron_BA1-2': Array([ 0. , -0.00644561, 0. , ..., 0.96711063,\n", + " -0.66123384, 0. ], dtype=float64)}, 'theta': {'ge_bias': Array([-8.17273411], dtype=float64), 'ge_scale': Array([11.973], dtype=float64)}}, t=Array(2502.95282886, dtype=float64, weak_type=True))\n" + ] + } + ], + "source": [ + "print(model.state)" ] }, { @@ -1397,13 +1547,13 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 21, "id": "fc8f6c11", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1421,95 +1571,242 @@ "plt.show()" ] }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "0345a4c6", - "metadata": {}, - "source": [ - "We can also take a quick look at the distribution of any parameter set in the model. Below we'll take a look at the distribution of shift parameters for the non reference BA1 condition. The distribution, by default, splits the shifts associated with stop codon mutations as a sanity check for the model fit. We expect stop codons to be equally deleterious no matter which condition they occur in, and thus, they should primarily be zero." - ] - }, { "cell_type": "code", - "execution_count": 20, - "id": "8228b5ff", + "execution_count": 22, + "id": "c0fcec26", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "{'shift': {'Delta-2': array([0., 0., 0., ..., 0., 0., 0.]),\n", + " 'Omicron_BA1-2': array([ 0. , -0.00644573, 0. , ..., 0.96713367,\n", + " -0.66127992, -0. ])},\n", + " 'theta': {'ge_bias': Array([-8.17271859], dtype=float64),\n", + " 'ge_scale': Array([11.973], dtype=float64)},\n", + " 'beta': {'Delta-2': Array([-0.67037649, -1.21083294, 0.37633261, ..., -0.63905219,\n", + " 0.09754517, 0.60171278], dtype=float64),\n", + " 'Omicron_BA1-2': Array([-0.67037649, -1.21727867, 0.37633261, ..., 0.32808149,\n", + " -0.56373475, 0.60171278], dtype=float64)},\n", + " 'beta0': {'Delta-2': Array([0.75802565], dtype=float64),\n", + " 'Omicron_BA1-2': Array([-1.15687509], dtype=float64)}}" ] }, + "execution_count": 22, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ - "fig, ax = plt.subplots(figsize=[8,4])\n", - "agg_func = lambda x: onp.abs(onp.mean(onp.sum(x)))\n", - "model.plot_param_hist(\"shift_Omicron_BA1-2\", ax=ax, show=False)\n", - "ax.set_yscale(\"log\")\n", - "ax.legend()\n", - "ax.set_ylabel(\"log value\")\n", - "ax.set_title(\"Shift parameter value distribution\")\n", - "plt.show()" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "855ad82b", - "metadata": {}, - "source": [ - "Perhaps the best way to explore parameter values associated with individual mutations, is `Model.mut_shift_plot()` which offers the ability to interactively visualize a model's _beta_ ($\\beta_m$), experimental _shift_ ($\\Delta_{d,m}$), and _phenotype_ predictions ($\\hat{y}_{m, d}$). The plot is interactive, and allows you to hover over a mutation to see the associated values. The plot also allows you to zoom in on a region of interest using the site zoom bar. " + "model.params" ] }, { "cell_type": "code", "execution_count": 23, - "id": "3adf1b46", + "id": "e8e38c95", "metadata": {}, "outputs": [ { "data": { "text/html": [ + "
\n", + "\n", - "
\n", - "" ], "text/plain": [ "alt.VConcatChart(...)" ] }, - "execution_count": 23, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -1566,7 +1863,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 26, "id": "d64d1dbb", "metadata": {}, "outputs": [ @@ -1575,23 +1872,23 @@ "text/html": [ "\n", "\n", - "
\n", + "
\n", "" ], "text/plain": [ "alt.VConcatChart(...)" ] }, - "execution_count": 24, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -1655,7 +1952,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 27, "id": "121798e1", "metadata": {}, "outputs": [ @@ -1664,23 +1961,23 @@ "text/html": [ "\n", "\n", - "
\n", + "
\n", "" ], "text/plain": [ "alt.VConcatChart(...)" ] }, - "execution_count": 25, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -1753,7 +2050,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 28, "id": "1fa1aae5", "metadata": {}, "outputs": [], @@ -1801,7 +2098,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 33, "id": "71863ff4", "metadata": {}, "outputs": [ @@ -1886,7 +2183,7 @@ " 432316\n", " -0.7932\n", " G614K Q762E Q1071R\n", - " Omicron_BA.2\n", + " Omicron_BA2\n", " 2\n", " 3\n", " \n", @@ -1894,7 +2191,7 @@ " 432317\n", " -0.3706\n", " D339T\n", - " Omicron_BA.2\n", + " Omicron_BA2\n", " 2\n", " 1\n", " \n", @@ -1902,7 +2199,7 @@ " 432318\n", " -0.6116\n", " I358L T1006I T1066S T1077A\n", - " Omicron_BA.2\n", + " Omicron_BA2\n", " 2\n", " 4\n", " \n", @@ -1910,7 +2207,7 @@ " 432319\n", " -0.4363\n", " S408R R765L K1073E\n", - " Omicron_BA.2\n", + " Omicron_BA2\n", " 2\n", " 3\n", " \n", @@ -1918,7 +2215,7 @@ " 432320\n", " -3.5000\n", " S98A A570M D1163Y S1252C\n", - " Omicron_BA.2\n", + " Omicron_BA2\n", " 2\n", " 4\n", " \n", @@ -1928,18 +2225,18 @@ "
" ], "text/plain": [ - " func_score aa_substitutions condition replicate \\\n", - "0 -0.5087 L24V F486L D820E Delta 1 \n", - "1 -0.1940 N1125K Delta 1 \n", - "2 0.9906 V16I D138C F456Y T678S E990D Delta 1 \n", - "3 -0.6554 G75S T76I M731I L1004F Delta 1 \n", - "4 -3.5000 L176S L229P K558R S975Y T998S Delta 1 \n", - "... ... ... ... ... \n", - "432316 -0.7932 G614K Q762E Q1071R Omicron_BA.2 2 \n", - "432317 -0.3706 D339T Omicron_BA.2 2 \n", - "432318 -0.6116 I358L T1006I T1066S T1077A Omicron_BA.2 2 \n", - "432319 -0.4363 S408R R765L K1073E Omicron_BA.2 2 \n", - "432320 -3.5000 S98A A570M D1163Y S1252C Omicron_BA.2 2 \n", + " func_score aa_substitutions condition replicate \\\n", + "0 -0.5087 L24V F486L D820E Delta 1 \n", + "1 -0.1940 N1125K Delta 1 \n", + "2 0.9906 V16I D138C F456Y T678S E990D Delta 1 \n", + "3 -0.6554 G75S T76I M731I L1004F Delta 1 \n", + "4 -3.5000 L176S L229P K558R S975Y T998S Delta 1 \n", + "... ... ... ... ... \n", + "432316 -0.7932 G614K Q762E Q1071R Omicron_BA2 2 \n", + "432317 -0.3706 D339T Omicron_BA2 2 \n", + "432318 -0.6116 I358L T1006I T1066S T1077A Omicron_BA2 2 \n", + "432319 -0.4363 S408R R765L K1073E Omicron_BA2 2 \n", + "432320 -3.5000 S98A A570M D1163Y S1252C Omicron_BA2 2 \n", "\n", " n_subs \n", "0 3 \n", @@ -1957,19 +2254,23 @@ "[432321 rows x 5 columns]" ] }, - "execution_count": 27, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "func_score_df = pd.read_csv(\"docs_func_score_df_delta_BA1_BA2.csv\").fillna(\"\")\n", + "func_score_df = (\n", + " pd.read_csv(\"docs_func_score_df_delta_BA1_BA2.csv\")\n", + " .fillna(\"\")\n", + " .replace({\"Omicron_BA.1\" : \"Omicron_BA1\", \"Omicron_BA.2\" : \"Omicron_BA2\"})\n", + ")\n", "func_score_df" ] }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 34, "id": "c9449c29", "metadata": {}, "outputs": [ @@ -1996,6 +2297,27 @@ "func_score_df.info()" ] }, + { + "cell_type": "code", + "execution_count": 35, + "id": "b4ebf908", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(['Delta', 'Omicron_BA1', 'Omicron_BA2'], dtype=object)" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "func_score_df.condition.unique()" + ] + }, { "cell_type": "markdown", "id": "4595b256", @@ -2008,15 +2330,37 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 36, "id": "bef3c901", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jgallowa/mambaforge/envs/multidms-dev/lib/python3.11/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n", + " self.pid = os.fork()\n", + "/home/jgallowa/mambaforge/envs/multidms-dev/lib/python3.11/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n", + " self.pid = os.fork()\n", + "/home/jgallowa/mambaforge/envs/multidms-dev/lib/python3.11/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n", + " self.pid = os.fork()\n", + "/home/jgallowa/mambaforge/envs/multidms-dev/lib/python3.11/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n", + " self.pid = os.fork()\n", + "/home/jgallowa/mambaforge/envs/multidms-dev/lib/python3.11/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n", + " self.pid = os.fork()\n", + "/home/jgallowa/mambaforge/envs/multidms-dev/lib/python3.11/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n", + " self.pid = os.fork()\n", + "/home/jgallowa/mambaforge/envs/multidms-dev/lib/python3.11/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n", + " self.pid = os.fork()\n", + "/home/jgallowa/mambaforge/envs/multidms-dev/lib/python3.11/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n", + " self.pid = os.fork()\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "{1: Data(Replicate 1), 2: Data(Replicate 2)}\n" + "{1: Data, 2: Data}\n" ] } ], @@ -2047,7 +2391,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 37, "id": "544c1598", "metadata": {}, "outputs": [], @@ -2084,38 +2428,32 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 38, "id": "d68ea914", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "model Model(Model-1)\n", - "dataset_name Replicate 1\n", - "step_loss [6.707913875579834, 0.6865768432617188]\n", - "epistatic_model Sigmoid\n", - "output_activation Identity\n", - "scale_coeff_lasso_shift 0.00001\n", - "scale_coeff_ridge_beta 0\n", - "scale_coeff_ridge_shift 0\n", - "scale_coeff_ridge_gamma 0\n", - "scale_coeff_ridge_alpha_d 0.001\n", - "huber_scale_huber 1\n", - "gamma_corrected False\n", - "alpha_d True\n", - "init_beta_naught 0.0\n", - "lock_beta_naught_at None\n", - "tol 0.0001\n", - "num_training_steps 1\n", - "iterations_per_step 15000\n", - "n_hidden_units 5\n", - "lower_bound None\n", - "PRNGKey 0\n", + "epistatic_model Sigmoid\n", + "output_activation Identity\n", + "init_theta_scale 6.5\n", + "init_theta_bias -3.5\n", + "n_hidden_units 5\n", + "lower_bound None\n", + "PRNGKey 0\n", + "num_training_steps 1\n", + "iterations_per_step 15000\n", + "alpha_d True\n", + "scale_coeff_ridge_alpha_d 0.001\n", + "scale_coeff_lasso_shift 0.00001\n", + "dataset_name Replicate 1\n", + "model Model\\nName: unnamed\\nData: Replicate 1\\nConve...\n", + "fit_time 88\n", "dtype: object" ] }, - "execution_count": 31, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" } @@ -2135,7 +2473,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 39, "id": "475fafe3", "metadata": {}, "outputs": [ @@ -2144,23 +2482,23 @@ "text/html": [ "\n", "\n", - "
\n", + "
\n", "" ], "text/plain": [ "alt.VConcatChart(...)" ] }, - "execution_count": 32, + "execution_count": 39, "metadata": {}, "output_type": "execute_result" } @@ -2234,19 +2572,18 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 45, "id": "b1b6438f", "metadata": {}, "outputs": [], "source": [ "collection_params = {\n", " \"dataset\": list(data_replicates.values()),\n", - " \"num_training_steps\" : [1],\n", - " \"iterations_per_step\": [15000],\n", + " \"maxiter\": [1000],\n", " \"output_activation\" : [\"Softplus\"],\n", " \"lower_bound\" : [-3.5],\n", - " \"alpha_d\" : [True],\n", - " \"scale_coeff_ridge_alpha_d\": [1e-3],\n", + " \"scale_coeff_ridge_beta\" : [1e-6],\n", + " \"scale_coeff_ridge_ge_scale\": [1e-3],\n", " \"scale_coeff_lasso_shift\": [0.0, 1e-6, 1e-5, 5e-5, 1e-4, 1e-3],\n", "}" ] @@ -2261,7 +2598,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 47, "id": "c0dc0e7f", "metadata": {}, "outputs": [ @@ -2269,108 +2606,26 @@ "name": "stdout", "output_type": "stream", "text": [ - "[{'alpha_d': True,\n", - " 'dataset': Data(Replicate 1),\n", - " 'iterations_per_step': 15000,\n", - " 'lower_bound': -3.5,\n", - " 'num_training_steps': 1,\n", - " 'output_activation': 'Softplus',\n", - " 'scale_coeff_lasso_shift': 0.0,\n", - " 'scale_coeff_ridge_alpha_d': 0.001},\n", - " {'alpha_d': True,\n", - " 'dataset': Data(Replicate 1),\n", - " 'iterations_per_step': 15000,\n", - " 'lower_bound': -3.5,\n", - " 'num_training_steps': 1,\n", - " 'output_activation': 'Softplus',\n", - " 'scale_coeff_lasso_shift': 1e-06,\n", - " 'scale_coeff_ridge_alpha_d': 0.001},\n", - " {'alpha_d': True,\n", - " 'dataset': Data(Replicate 1),\n", - " 'iterations_per_step': 15000,\n", - " 'lower_bound': -3.5,\n", - " 'num_training_steps': 1,\n", - " 'output_activation': 'Softplus',\n", - " 'scale_coeff_lasso_shift': 1e-05,\n", - " 'scale_coeff_ridge_alpha_d': 0.001},\n", - " {'alpha_d': True,\n", - " 'dataset': Data(Replicate 1),\n", - " 'iterations_per_step': 15000,\n", - " 'lower_bound': -3.5,\n", - " 'num_training_steps': 1,\n", - " 'output_activation': 'Softplus',\n", - " 'scale_coeff_lasso_shift': 5e-05,\n", - " 'scale_coeff_ridge_alpha_d': 0.001},\n", - " {'alpha_d': True,\n", - " 'dataset': Data(Replicate 1),\n", - " 'iterations_per_step': 15000,\n", + "[{'dataset': Data,\n", " 'lower_bound': -3.5,\n", - " 'num_training_steps': 1,\n", - " 'output_activation': 'Softplus',\n", - " 'scale_coeff_lasso_shift': 0.0001,\n", - " 'scale_coeff_ridge_alpha_d': 0.001},\n", - " {'alpha_d': True,\n", - " 'dataset': Data(Replicate 1),\n", - " 'iterations_per_step': 15000,\n", - " 'lower_bound': -3.5,\n", - " 'num_training_steps': 1,\n", - " 'output_activation': 'Softplus',\n", - " 'scale_coeff_lasso_shift': 0.001,\n", - " 'scale_coeff_ridge_alpha_d': 0.001},\n", - " {'alpha_d': True,\n", - " 'dataset': Data(Replicate 2),\n", - " 'iterations_per_step': 15000,\n", - " 'lower_bound': -3.5,\n", - " 'num_training_steps': 1,\n", + " 'maxiter': 1000,\n", " 'output_activation': 'Softplus',\n", " 'scale_coeff_lasso_shift': 0.0,\n", - " 'scale_coeff_ridge_alpha_d': 0.001},\n", - " {'alpha_d': True,\n", - " 'dataset': Data(Replicate 2),\n", - " 'iterations_per_step': 15000,\n", + " 'scale_coeff_ridge_beta': 1e-06,\n", + " 'scale_coeff_ridge_ge_scale': 0.001},\n", + " {'dataset': Data,\n", " 'lower_bound': -3.5,\n", - " 'num_training_steps': 1,\n", + " 'maxiter': 1000,\n", " 'output_activation': 'Softplus',\n", " 'scale_coeff_lasso_shift': 1e-06,\n", - " 'scale_coeff_ridge_alpha_d': 0.001},\n", - " {'alpha_d': True,\n", - " 'dataset': Data(Replicate 2),\n", - " 'iterations_per_step': 15000,\n", - " 'lower_bound': -3.5,\n", - " 'num_training_steps': 1,\n", - " 'output_activation': 'Softplus',\n", - " 'scale_coeff_lasso_shift': 1e-05,\n", - " 'scale_coeff_ridge_alpha_d': 0.001},\n", - " {'alpha_d': True,\n", - " 'dataset': Data(Replicate 2),\n", - " 'iterations_per_step': 15000,\n", - " 'lower_bound': -3.5,\n", - " 'num_training_steps': 1,\n", - " 'output_activation': 'Softplus',\n", - " 'scale_coeff_lasso_shift': 5e-05,\n", - " 'scale_coeff_ridge_alpha_d': 0.001},\n", - " {'alpha_d': True,\n", - " 'dataset': Data(Replicate 2),\n", - " 'iterations_per_step': 15000,\n", - " 'lower_bound': -3.5,\n", - " 'num_training_steps': 1,\n", - " 'output_activation': 'Softplus',\n", - " 'scale_coeff_lasso_shift': 0.0001,\n", - " 'scale_coeff_ridge_alpha_d': 0.001},\n", - " {'alpha_d': True,\n", - " 'dataset': Data(Replicate 2),\n", - " 'iterations_per_step': 15000,\n", - " 'lower_bound': -3.5,\n", - " 'num_training_steps': 1,\n", - " 'output_activation': 'Softplus',\n", - " 'scale_coeff_lasso_shift': 0.001,\n", - " 'scale_coeff_ridge_alpha_d': 0.001}]\n" + " 'scale_coeff_ridge_beta': 1e-06,\n", + " 'scale_coeff_ridge_ge_scale': 0.001}]\n" ] } ], "source": [ "from pprint import pprint\n", - "pprint(multidms.model_collection._explode_params_dict(collection_params))" + "pprint(multidms.utils.explode_params_dict(collection_params)[:2])" ] }, { @@ -2383,12 +2638,12 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 49, "id": "1454a6d2", "metadata": {}, "outputs": [], "source": [ - "n_fit, n_failed, fit_models = multidms.model_collection.fit_models(collection_params, n_threads=4)" + "n_fit, n_failed, fit_models = multidms.model_collection.fit_models(collection_params, n_threads=12)" ] }, { @@ -2401,7 +2656,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 50, "id": "f4c28eda", "metadata": {}, "outputs": [ @@ -2426,412 +2681,290 @@ " \n", " \n", " \n", - " model\n", - " dataset_name\n", - " step_loss\n", " epistatic_model\n", " output_activation\n", - " scale_coeff_lasso_shift\n", - " scale_coeff_ridge_beta\n", - " scale_coeff_ridge_shift\n", - " scale_coeff_ridge_gamma\n", - " scale_coeff_ridge_alpha_d\n", - " ...\n", - " gamma_corrected\n", - " alpha_d\n", - " init_beta_naught\n", - " lock_beta_naught_at\n", - " tol\n", - " num_training_steps\n", - " iterations_per_step\n", + " init_theta_scale\n", + " init_theta_bias\n", " n_hidden_units\n", " lower_bound\n", " PRNGKey\n", + " maxiter\n", + " scale_coeff_lasso_shift\n", + " scale_coeff_ridge_beta\n", + " scale_coeff_ridge_ge_scale\n", + " dataset_name\n", + " model\n", + " fit_time\n", " \n", " \n", " \n", " \n", " 0\n", - " Model(Model-0)\n", - " Replicate 1\n", - " [4.571287155151367, 0.6238023638725281]\n", " Sigmoid\n", " Softplus\n", - " 0.0\n", - " 0\n", - " 0\n", - " 0\n", - " 0.001\n", - " ...\n", - " False\n", - " True\n", - " 0.0\n", - " None\n", - " 0.0001\n", - " 1\n", - " 15000\n", + " 6.5\n", + " -3.5\n", " 5\n", " -3.5\n", " 0\n", + " 1000\n", + " 0.0\n", + " 0.000001\n", + " 0.001\n", + " Replicate 1\n", + " Model\\nName: unnamed\\nData: Replicate 1\\nConve...\n", + " 109\n", " \n", " \n", " 1\n", - " Model(Model-0)\n", - " Replicate 1\n", - " [4.571287155151367, 0.6282336115837097]\n", " Sigmoid\n", " Softplus\n", - " 0.000001\n", - " 0\n", - " 0\n", - " 0\n", - " 0.001\n", - " ...\n", - " False\n", - " True\n", - " 0.0\n", - " None\n", - " 0.0001\n", - " 1\n", - " 15000\n", + " 6.5\n", + " -3.5\n", " 5\n", " -3.5\n", " 0\n", + " 1000\n", + " 0.000001\n", + " 0.000001\n", + " 0.001\n", + " Replicate 1\n", + " Model\\nName: unnamed\\nData: Replicate 1\\nConve...\n", + " 108\n", " \n", " \n", " 2\n", - " Model(Model-0)\n", - " Replicate 1\n", - " [4.571287155151367, 0.6726276278495789]\n", " Sigmoid\n", " Softplus\n", - " 0.00001\n", - " 0\n", - " 0\n", - " 0\n", - " 0.001\n", - " ...\n", - " False\n", - " True\n", - " 0.0\n", - " None\n", - " 0.0001\n", - " 1\n", - " 15000\n", + " 6.5\n", + " -3.5\n", " 5\n", " -3.5\n", " 0\n", + " 1000\n", + " 0.00001\n", + " 0.000001\n", + " 0.001\n", + " Replicate 1\n", + " Model\\nName: unnamed\\nData: Replicate 1\\nConve...\n", + " 108\n", " \n", " \n", " 3\n", - " Model(Model-0)\n", - " Replicate 1\n", - " [4.571287155151367, 0.8288853168487549]\n", " Sigmoid\n", " Softplus\n", - " 0.00005\n", - " 0\n", - " 0\n", - " 0\n", - " 0.001\n", - " ...\n", - " False\n", - " True\n", - " 0.0\n", - " None\n", - " 0.0001\n", - " 1\n", - " 15000\n", + " 6.5\n", + " -3.5\n", " 5\n", " -3.5\n", " 0\n", + " 1000\n", + " 0.00005\n", + " 0.000001\n", + " 0.001\n", + " Replicate 1\n", + " Model\\nName: unnamed\\nData: Replicate 1\\nConve...\n", + " 108\n", " \n", " \n", " 4\n", - " Model(Model-1)\n", - " Replicate 1\n", - " [4.571287155151367, 0.8795142769813538]\n", " Sigmoid\n", " Softplus\n", - " 0.0001\n", - " 0\n", - " 0\n", - " 0\n", - " 0.001\n", - " ...\n", - " False\n", - " True\n", - " 0.0\n", - " None\n", - " 0.0001\n", - " 1\n", - " 15000\n", + " 6.5\n", + " -3.5\n", " 5\n", " -3.5\n", " 0\n", + " 1000\n", + " 0.0001\n", + " 0.000001\n", + " 0.001\n", + " Replicate 1\n", + " Model\\nName: unnamed\\nData: Replicate 1\\nConve...\n", + " 109\n", " \n", " \n", " 5\n", - " Model(Model-1)\n", - " Replicate 1\n", - " [4.571287155151367, 0.9037127494812012]\n", " Sigmoid\n", " Softplus\n", - " 0.001\n", - " 0\n", - " 0\n", - " 0\n", - " 0.001\n", - " ...\n", - " False\n", - " True\n", - " 0.0\n", - " None\n", - " 0.0001\n", - " 1\n", - " 15000\n", + " 6.5\n", + " -3.5\n", " 5\n", " -3.5\n", " 0\n", + " 1000\n", + " 0.001\n", + " 0.000001\n", + " 0.001\n", + " Replicate 1\n", + " Model\\nName: unnamed\\nData: Replicate 1\\nConve...\n", + " 107\n", " \n", " \n", " 6\n", - " Model(Model-1)\n", - " Replicate 2\n", - " [3.9341390132904053, 0.5897706747055054]\n", " Sigmoid\n", " Softplus\n", - " 0.0\n", - " 0\n", - " 0\n", - " 0\n", - " 0.001\n", - " ...\n", - " False\n", - " True\n", - " 0.0\n", - " None\n", - " 0.0001\n", - " 1\n", - " 15000\n", + " 6.5\n", + " -3.5\n", " 5\n", " -3.5\n", " 0\n", + " 1000\n", + " 0.0\n", + " 0.000001\n", + " 0.001\n", + " Replicate 2\n", + " Model\\nName: unnamed\\nData: Replicate 2\\nConve...\n", + " 106\n", " \n", " \n", " 7\n", - " Model(Model-1)\n", - " Replicate 2\n", - " [3.9341390132904053, 0.5946934819221497]\n", " Sigmoid\n", " Softplus\n", - " 0.000001\n", - " 0\n", - " 0\n", - " 0\n", - " 0.001\n", - " ...\n", - " False\n", - " True\n", - " 0.0\n", - " None\n", - " 0.0001\n", - " 1\n", - " 15000\n", + " 6.5\n", + " -3.5\n", " 5\n", " -3.5\n", " 0\n", + " 1000\n", + " 0.000001\n", + " 0.000001\n", + " 0.001\n", + " Replicate 2\n", + " Model\\nName: unnamed\\nData: Replicate 2\\nConve...\n", + " 105\n", " \n", " \n", " 8\n", - " Model(Model-2)\n", - " Replicate 2\n", - " [3.9341390132904053, 0.6400377750396729]\n", " Sigmoid\n", " Softplus\n", - " 0.00001\n", - " 0\n", - " 0\n", - " 0\n", - " 0.001\n", - " ...\n", - " False\n", - " True\n", - " 0.0\n", - " None\n", - " 0.0001\n", - " 1\n", - " 15000\n", + " 6.5\n", + " -3.5\n", " 5\n", " -3.5\n", " 0\n", + " 1000\n", + " 0.00001\n", + " 0.000001\n", + " 0.001\n", + " Replicate 2\n", + " Model\\nName: unnamed\\nData: Replicate 2\\nConve...\n", + " 105\n", " \n", " \n", " 9\n", - " Model(Model-2)\n", - " Replicate 2\n", - " [3.9341390132904053, 0.7173289656639099]\n", " Sigmoid\n", " Softplus\n", - " 0.00005\n", - " 0\n", - " 0\n", - " 0\n", - " 0.001\n", - " ...\n", - " False\n", - " True\n", - " 0.0\n", - " None\n", - " 0.0001\n", - " 1\n", - " 15000\n", + " 6.5\n", + " -3.5\n", " 5\n", " -3.5\n", " 0\n", + " 1000\n", + " 0.00005\n", + " 0.000001\n", + " 0.001\n", + " Replicate 2\n", + " Model\\nName: unnamed\\nData: Replicate 2\\nConve...\n", + " 107\n", " \n", " \n", " 10\n", - " Model(Model-2)\n", - " Replicate 2\n", - " [3.9341390132904053, 0.8550326824188232]\n", " Sigmoid\n", " Softplus\n", - " 0.0001\n", - " 0\n", - " 0\n", - " 0\n", - " 0.001\n", - " ...\n", - " False\n", - " True\n", - " 0.0\n", - " None\n", - " 0.0001\n", - " 1\n", - " 15000\n", + " 6.5\n", + " -3.5\n", " 5\n", " -3.5\n", " 0\n", + " 1000\n", + " 0.0001\n", + " 0.000001\n", + " 0.001\n", + " Replicate 2\n", + " Model\\nName: unnamed\\nData: Replicate 2\\nConve...\n", + " 106\n", " \n", " \n", " 11\n", - " Model(Model-2)\n", - " Replicate 2\n", - " [3.9341390132904053, 0.881784200668335]\n", " Sigmoid\n", " Softplus\n", - " 0.001\n", - " 0\n", - " 0\n", - " 0\n", - " 0.001\n", - " ...\n", - " False\n", - " True\n", - " 0.0\n", - " None\n", - " 0.0001\n", - " 1\n", - " 15000\n", + " 6.5\n", + " -3.5\n", " 5\n", " -3.5\n", " 0\n", + " 1000\n", + " 0.001\n", + " 0.000001\n", + " 0.001\n", + " Replicate 2\n", + " Model\\nName: unnamed\\nData: Replicate 2\\nConve...\n", + " 106\n", " \n", " \n", "\n", - "

12 rows × 21 columns

\n", "" ], "text/plain": [ - " model dataset_name step_loss \\\n", - "0 Model(Model-0) Replicate 1 [4.571287155151367, 0.6238023638725281] \n", - "1 Model(Model-0) Replicate 1 [4.571287155151367, 0.6282336115837097] \n", - "2 Model(Model-0) Replicate 1 [4.571287155151367, 0.6726276278495789] \n", - "3 Model(Model-0) Replicate 1 [4.571287155151367, 0.8288853168487549] \n", - "4 Model(Model-1) Replicate 1 [4.571287155151367, 0.8795142769813538] \n", - "5 Model(Model-1) Replicate 1 [4.571287155151367, 0.9037127494812012] \n", - "6 Model(Model-1) Replicate 2 [3.9341390132904053, 0.5897706747055054] \n", - "7 Model(Model-1) Replicate 2 [3.9341390132904053, 0.5946934819221497] \n", - "8 Model(Model-2) Replicate 2 [3.9341390132904053, 0.6400377750396729] \n", - "9 Model(Model-2) Replicate 2 [3.9341390132904053, 0.7173289656639099] \n", - "10 Model(Model-2) Replicate 2 [3.9341390132904053, 0.8550326824188232] \n", - "11 Model(Model-2) Replicate 2 [3.9341390132904053, 0.881784200668335] \n", - "\n", - " epistatic_model output_activation scale_coeff_lasso_shift \\\n", - "0 Sigmoid Softplus 0.0 \n", - "1 Sigmoid Softplus 0.000001 \n", - "2 Sigmoid Softplus 0.00001 \n", - "3 Sigmoid Softplus 0.00005 \n", - "4 Sigmoid Softplus 0.0001 \n", - "5 Sigmoid Softplus 0.001 \n", - "6 Sigmoid Softplus 0.0 \n", - "7 Sigmoid Softplus 0.000001 \n", - "8 Sigmoid Softplus 0.00001 \n", - "9 Sigmoid Softplus 0.00005 \n", - "10 Sigmoid Softplus 0.0001 \n", - "11 Sigmoid Softplus 0.001 \n", - "\n", - " scale_coeff_ridge_beta scale_coeff_ridge_shift scale_coeff_ridge_gamma \\\n", - "0 0 0 0 \n", - "1 0 0 0 \n", - "2 0 0 0 \n", - "3 0 0 0 \n", - "4 0 0 0 \n", - "5 0 0 0 \n", - "6 0 0 0 \n", - "7 0 0 0 \n", - "8 0 0 0 \n", - "9 0 0 0 \n", - "10 0 0 0 \n", - "11 0 0 0 \n", - "\n", - " scale_coeff_ridge_alpha_d ... gamma_corrected alpha_d init_beta_naught \\\n", - "0 0.001 ... False True 0.0 \n", - "1 0.001 ... False True 0.0 \n", - "2 0.001 ... False True 0.0 \n", - "3 0.001 ... False True 0.0 \n", - "4 0.001 ... False True 0.0 \n", - "5 0.001 ... False True 0.0 \n", - "6 0.001 ... False True 0.0 \n", - "7 0.001 ... False True 0.0 \n", - "8 0.001 ... False True 0.0 \n", - "9 0.001 ... False True 0.0 \n", - "10 0.001 ... False True 0.0 \n", - "11 0.001 ... False True 0.0 \n", - "\n", - " lock_beta_naught_at tol num_training_steps iterations_per_step \\\n", - "0 None 0.0001 1 15000 \n", - "1 None 0.0001 1 15000 \n", - "2 None 0.0001 1 15000 \n", - "3 None 0.0001 1 15000 \n", - "4 None 0.0001 1 15000 \n", - "5 None 0.0001 1 15000 \n", - "6 None 0.0001 1 15000 \n", - "7 None 0.0001 1 15000 \n", - "8 None 0.0001 1 15000 \n", - "9 None 0.0001 1 15000 \n", - "10 None 0.0001 1 15000 \n", - "11 None 0.0001 1 15000 \n", - "\n", - " n_hidden_units lower_bound PRNGKey \n", - "0 5 -3.5 0 \n", - "1 5 -3.5 0 \n", - "2 5 -3.5 0 \n", - "3 5 -3.5 0 \n", - "4 5 -3.5 0 \n", - "5 5 -3.5 0 \n", - "6 5 -3.5 0 \n", - "7 5 -3.5 0 \n", - "8 5 -3.5 0 \n", - "9 5 -3.5 0 \n", - "10 5 -3.5 0 \n", - "11 5 -3.5 0 \n", - "\n", - "[12 rows x 21 columns]" + " epistatic_model output_activation init_theta_scale init_theta_bias \\\n", + "0 Sigmoid Softplus 6.5 -3.5 \n", + "1 Sigmoid Softplus 6.5 -3.5 \n", + "2 Sigmoid Softplus 6.5 -3.5 \n", + "3 Sigmoid Softplus 6.5 -3.5 \n", + "4 Sigmoid Softplus 6.5 -3.5 \n", + "5 Sigmoid Softplus 6.5 -3.5 \n", + "6 Sigmoid Softplus 6.5 -3.5 \n", + "7 Sigmoid Softplus 6.5 -3.5 \n", + "8 Sigmoid Softplus 6.5 -3.5 \n", + "9 Sigmoid Softplus 6.5 -3.5 \n", + "10 Sigmoid Softplus 6.5 -3.5 \n", + "11 Sigmoid Softplus 6.5 -3.5 \n", + "\n", + " n_hidden_units lower_bound PRNGKey maxiter scale_coeff_lasso_shift \\\n", + "0 5 -3.5 0 1000 0.0 \n", + "1 5 -3.5 0 1000 0.000001 \n", + "2 5 -3.5 0 1000 0.00001 \n", + "3 5 -3.5 0 1000 0.00005 \n", + "4 5 -3.5 0 1000 0.0001 \n", + "5 5 -3.5 0 1000 0.001 \n", + "6 5 -3.5 0 1000 0.0 \n", + "7 5 -3.5 0 1000 0.000001 \n", + "8 5 -3.5 0 1000 0.00001 \n", + "9 5 -3.5 0 1000 0.00005 \n", + "10 5 -3.5 0 1000 0.0001 \n", + "11 5 -3.5 0 1000 0.001 \n", + "\n", + " scale_coeff_ridge_beta scale_coeff_ridge_ge_scale dataset_name \\\n", + "0 0.000001 0.001 Replicate 1 \n", + "1 0.000001 0.001 Replicate 1 \n", + "2 0.000001 0.001 Replicate 1 \n", + "3 0.000001 0.001 Replicate 1 \n", + "4 0.000001 0.001 Replicate 1 \n", + "5 0.000001 0.001 Replicate 1 \n", + "6 0.000001 0.001 Replicate 2 \n", + "7 0.000001 0.001 Replicate 2 \n", + "8 0.000001 0.001 Replicate 2 \n", + "9 0.000001 0.001 Replicate 2 \n", + "10 0.000001 0.001 Replicate 2 \n", + "11 0.000001 0.001 Replicate 2 \n", + "\n", + " model fit_time \n", + "0 Model\\nName: unnamed\\nData: Replicate 1\\nConve... 109 \n", + "1 Model\\nName: unnamed\\nData: Replicate 1\\nConve... 108 \n", + "2 Model\\nName: unnamed\\nData: Replicate 1\\nConve... 108 \n", + "3 Model\\nName: unnamed\\nData: Replicate 1\\nConve... 108 \n", + "4 Model\\nName: unnamed\\nData: Replicate 1\\nConve... 109 \n", + "5 Model\\nName: unnamed\\nData: Replicate 1\\nConve... 107 \n", + "6 Model\\nName: unnamed\\nData: Replicate 2\\nConve... 106 \n", + "7 Model\\nName: unnamed\\nData: Replicate 2\\nConve... 105 \n", + "8 Model\\nName: unnamed\\nData: Replicate 2\\nConve... 105 \n", + "9 Model\\nName: unnamed\\nData: Replicate 2\\nConve... 107 \n", + "10 Model\\nName: unnamed\\nData: Replicate 2\\nConve... 106 \n", + "11 Model\\nName: unnamed\\nData: Replicate 2\\nConve... 106 " ] }, - "execution_count": 36, + "execution_count": 50, "metadata": {}, "output_type": "execute_result" } @@ -2866,7 +2999,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 51, "id": "1e78a46e", "metadata": {}, "outputs": [], @@ -2884,7 +3017,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 52, "id": "91907a87", "metadata": {}, "outputs": [ @@ -2918,15 +3051,17 @@ " \n", " \n", " mutation\n", - " beta\n", - " shift_Omicron_BA.1\n", - " shift_Omicron_BA.2\n", - " predicted_func_score_Delta\n", - " predicted_func_score_Omicron_BA.1\n", - " predicted_func_score_Omicron_BA.2\n", " times_seen_Delta\n", - " times_seen_Omicron_BA.1\n", - " times_seen_Omicron_BA.2\n", + " times_seen_Omicron_BA1\n", + " times_seen_Omicron_BA2\n", + " beta_Delta\n", + " beta_Omicron_BA1\n", + " shift_Omicron_BA1\n", + " beta_Omicron_BA2\n", + " shift_Omicron_BA2\n", + " predicted_func_score_Delta\n", + " predicted_func_score_Omicron_BA1\n", + " predicted_func_score_Omicron_BA2\n", " \n", " \n", " dataset_name\n", @@ -2941,6 +3076,8 @@ " \n", " \n", " \n", + " \n", + " \n", " \n", " \n", " \n", @@ -2948,139 +3085,149 @@ " Replicate 1\n", " 0.0\n", " A1015D\n", - " -4.263447\n", - " -4.168998\n", - " -0.246434\n", - " -1.940598\n", - " -3.193376\n", - " -2.054570\n", " 5.0\n", " 2.0\n", " 3.0\n", + " -1.199526\n", + " -1.955241\n", + " -0.755714\n", + " -0.851112\n", + " 0.348414\n", + " -1.554889\n", + " -2.520092\n", + " -1.083576\n", " \n", " \n", " 0.0\n", " A1015Q\n", - " -6.989111\n", - " -3.998795\n", - " 0.000000\n", - " -3.151047\n", - " -3.223423\n", - " -3.069028\n", " 0.0\n", " 8.0\n", " 0.0\n", + " -0.048907\n", + " -2.681171\n", + " -2.632264\n", + " -0.000320\n", + " 0.048587\n", + " -0.053516\n", + " -3.140728\n", + " -0.000353\n", " \n", " \n", " 0.0\n", " A1015S\n", - " -0.019358\n", - " -1.080333\n", - " -0.496059\n", - " -0.001317\n", - " -0.068060\n", - " 0.037278\n", " 8.0\n", " 22.0\n", " 29.0\n", + " 0.179238\n", + " -0.256491\n", + " -0.435729\n", + " -0.196018\n", + " -0.375256\n", + " 0.185579\n", + " -0.303580\n", + " -0.225457\n", " \n", " \n", " 0.0\n", " A1015T\n", - " -9.385324\n", - " -1.990580\n", - " 1.863133\n", - " -3.275185\n", - " -3.224236\n", - " -3.124743\n", " 7.0\n", " 12.0\n", " 22.0\n", + " -1.782984\n", + " -1.990034\n", + " -0.207050\n", + " -1.834713\n", + " -0.051728\n", + " -2.318638\n", + " -2.557530\n", + " -2.383881\n", " \n", " \n", " 0.0\n", " A1015V\n", - " -4.685401\n", - " -4.448816\n", - " -1.000862\n", - " -2.263942\n", - " -3.209804\n", - " -2.743822\n", " 0.0\n", " 6.0\n", " 7.0\n", + " -0.080035\n", + " -2.431665\n", + " -2.351630\n", + " -1.975145\n", + " -1.895110\n", + " -0.088201\n", + " -2.972883\n", + " -2.542748\n", " \n", " \n", "\n", "" ], "text/plain": [ - " mutation beta shift_Omicron_BA.1 \\\n", - "dataset_name scale_coeff_lasso_shift \n", - "Replicate 1 0.0 A1015D -4.263447 -4.168998 \n", - " 0.0 A1015Q -6.989111 -3.998795 \n", - " 0.0 A1015S -0.019358 -1.080333 \n", - " 0.0 A1015T -9.385324 -1.990580 \n", - " 0.0 A1015V -4.685401 -4.448816 \n", - "\n", - " shift_Omicron_BA.2 \\\n", - "dataset_name scale_coeff_lasso_shift \n", - "Replicate 1 0.0 -0.246434 \n", - " 0.0 0.000000 \n", - " 0.0 -0.496059 \n", - " 0.0 1.863133 \n", - " 0.0 -1.000862 \n", + " mutation times_seen_Delta \\\n", + "dataset_name scale_coeff_lasso_shift \n", + "Replicate 1 0.0 A1015D 5.0 \n", + " 0.0 A1015Q 0.0 \n", + " 0.0 A1015S 8.0 \n", + " 0.0 A1015T 7.0 \n", + " 0.0 A1015V 0.0 \n", + "\n", + " times_seen_Omicron_BA1 \\\n", + "dataset_name scale_coeff_lasso_shift \n", + "Replicate 1 0.0 2.0 \n", + " 0.0 8.0 \n", + " 0.0 22.0 \n", + " 0.0 12.0 \n", + " 0.0 6.0 \n", + "\n", + " times_seen_Omicron_BA2 beta_Delta \\\n", + "dataset_name scale_coeff_lasso_shift \n", + "Replicate 1 0.0 3.0 -1.199526 \n", + " 0.0 0.0 -0.048907 \n", + " 0.0 29.0 0.179238 \n", + " 0.0 22.0 -1.782984 \n", + " 0.0 7.0 -0.080035 \n", + "\n", + " beta_Omicron_BA1 shift_Omicron_BA1 \\\n", + "dataset_name scale_coeff_lasso_shift \n", + "Replicate 1 0.0 -1.955241 -0.755714 \n", + " 0.0 -2.681171 -2.632264 \n", + " 0.0 -0.256491 -0.435729 \n", + " 0.0 -1.990034 -0.207050 \n", + " 0.0 -2.431665 -2.351630 \n", + "\n", + " beta_Omicron_BA2 shift_Omicron_BA2 \\\n", + "dataset_name scale_coeff_lasso_shift \n", + "Replicate 1 0.0 -0.851112 0.348414 \n", + " 0.0 -0.000320 0.048587 \n", + " 0.0 -0.196018 -0.375256 \n", + " 0.0 -1.834713 -0.051728 \n", + " 0.0 -1.975145 -1.895110 \n", "\n", " predicted_func_score_Delta \\\n", "dataset_name scale_coeff_lasso_shift \n", - "Replicate 1 0.0 -1.940598 \n", - " 0.0 -3.151047 \n", - " 0.0 -0.001317 \n", - " 0.0 -3.275185 \n", - " 0.0 -2.263942 \n", - "\n", - " predicted_func_score_Omicron_BA.1 \\\n", - "dataset_name scale_coeff_lasso_shift \n", - "Replicate 1 0.0 -3.193376 \n", - " 0.0 -3.223423 \n", - " 0.0 -0.068060 \n", - " 0.0 -3.224236 \n", - " 0.0 -3.209804 \n", - "\n", - " predicted_func_score_Omicron_BA.2 \\\n", - "dataset_name scale_coeff_lasso_shift \n", - "Replicate 1 0.0 -2.054570 \n", - " 0.0 -3.069028 \n", - " 0.0 0.037278 \n", - " 0.0 -3.124743 \n", - " 0.0 -2.743822 \n", - "\n", - " times_seen_Delta \\\n", - "dataset_name scale_coeff_lasso_shift \n", - "Replicate 1 0.0 5.0 \n", - " 0.0 0.0 \n", - " 0.0 8.0 \n", - " 0.0 7.0 \n", - " 0.0 0.0 \n", - "\n", - " times_seen_Omicron_BA.1 \\\n", - "dataset_name scale_coeff_lasso_shift \n", - "Replicate 1 0.0 2.0 \n", - " 0.0 8.0 \n", - " 0.0 22.0 \n", - " 0.0 12.0 \n", - " 0.0 6.0 \n", - "\n", - " times_seen_Omicron_BA.2 \n", - "dataset_name scale_coeff_lasso_shift \n", - "Replicate 1 0.0 3.0 \n", - " 0.0 0.0 \n", - " 0.0 29.0 \n", - " 0.0 22.0 \n", - " 0.0 7.0 " + "Replicate 1 0.0 -1.554889 \n", + " 0.0 -0.053516 \n", + " 0.0 0.185579 \n", + " 0.0 -2.318638 \n", + " 0.0 -0.088201 \n", + "\n", + " predicted_func_score_Omicron_BA1 \\\n", + "dataset_name scale_coeff_lasso_shift \n", + "Replicate 1 0.0 -2.520092 \n", + " 0.0 -3.140728 \n", + " 0.0 -0.303580 \n", + " 0.0 -2.557530 \n", + " 0.0 -2.972883 \n", + "\n", + " predicted_func_score_Omicron_BA2 \n", + "dataset_name scale_coeff_lasso_shift \n", + "Replicate 1 0.0 -1.083576 \n", + " 0.0 -0.000353 \n", + " 0.0 -0.225457 \n", + " 0.0 -2.383881 \n", + " 0.0 -2.542748 " ] }, - "execution_count": 38, + "execution_count": 52, "metadata": {}, "output_type": "execute_result" } @@ -3108,7 +3255,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 53, "id": "8b09dd63", "metadata": {}, "outputs": [ @@ -3124,23 +3271,23 @@ "text/html": [ "\n", "\n", - "
\n", + "
\n", "" ], "text/plain": [ "alt.FacetChart(...)" ] }, - "execution_count": 39, + "execution_count": 53, "metadata": {}, "output_type": "execute_result" } @@ -3213,7 +3360,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 54, "id": "1c2a4245", "metadata": {}, "outputs": [ @@ -3222,23 +3369,23 @@ "text/html": [ "\n", "\n", - "
\n", + "
\n", "" ], "text/plain": [ "alt.FacetChart(...)" ] }, - "execution_count": 40, + "execution_count": 54, "metadata": {}, "output_type": "execute_result" } @@ -3334,10 +3481,18 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 55, "id": "efba0f52", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jgallowa/Projects/multidms/multidms/model_collection.py:670: UserWarning: the fits that will be aggregated appear to differ by features other than dataset_name, this may result in unexpected behavior\n", + " warnings.warn(\n" + ] + }, { "name": "stdout", "output_type": "stream", @@ -3350,23 +3505,23 @@ "text/html": [ "\n", "\n", - "
\n", + "
\n", "" ], "text/plain": [ "alt.VConcatChart(...)" ] }, - "execution_count": 41, + "execution_count": 55, "metadata": {}, "output_type": "execute_result" } @@ -3443,7 +3598,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 56, "id": "1fca3bc3", "metadata": {}, "outputs": [ @@ -3452,23 +3607,23 @@ "text/html": [ "\n", "\n", - "
\n", + "
\n", "" ], "text/plain": [ "alt.FacetChart(...)" ] }, - "execution_count": 42, + "execution_count": 56, "metadata": {}, "output_type": "execute_result" } diff --git a/notebooks/param_transform_ref_equivariance_prototype.ipynb b/notebooks/param_transform_ref_equivariance_prototype.ipynb index 7ed59ae..211d5a2 100644 --- a/notebooks/param_transform_ref_equivariance_prototype.ipynb +++ b/notebooks/param_transform_ref_equivariance_prototype.ipynb @@ -408,9 +408,21 @@ "execution_count": 5, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jgallowa/mambaforge/envs/multidms-dev/lib/python3.11/site-packages/seaborn/_base.py:948: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n", + " data_subset = grouped_data.get_group(pd_key)\n", + "/home/jgallowa/mambaforge/envs/multidms-dev/lib/python3.11/site-packages/seaborn/_base.py:948: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n", + " data_subset = grouped_data.get_group(pd_key)\n", + "/home/jgallowa/mambaforge/envs/multidms-dev/lib/python3.11/site-packages/seaborn/_base.py:948: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n", + " data_subset = grouped_data.get_group(pd_key)\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -631,9 +643,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/wsdewitt/miniconda3/envs/multidms/lib/python3.12/site-packages/pandas/core/arraylike.py:399: RuntimeWarning: divide by zero encountered in log2\n", + "/home/jgallowa/mambaforge/envs/multidms-dev/lib/python3.11/site-packages/pandas/core/arraylike.py:399: RuntimeWarning: divide by zero encountered in log2\n", " result = getattr(ufunc, method)(*inputs, **kwargs)\n", - "/Users/wsdewitt/miniconda3/envs/multidms/lib/python3.12/site-packages/pandas/core/arraylike.py:399: RuntimeWarning: divide by zero encountered in log2\n", + "/home/jgallowa/mambaforge/envs/multidms-dev/lib/python3.11/site-packages/pandas/core/arraylike.py:399: RuntimeWarning: divide by zero encountered in log2\n", " result = getattr(ufunc, method)(*inputs, **kwargs)\n" ] }, @@ -894,6 +906,15 @@ "cell_type": "code", "execution_count": 9, "metadata": {}, + "outputs": [], + "source": [ + "func_scores_collapsed_df[\"func_score\"] = func_scores_collapsed_df.func_score.clip(-3.5, 2.5)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, "outputs": [ { "data": { @@ -1002,7 +1023,7 @@ " 2\n", " 5\n", " 1\n", - " -6.693818\n", + " -3.500000\n", " \n", " \n", " 335514\n", @@ -1013,7 +1034,7 @@ " 2\n", " 3\n", " 1\n", - " -6.537503\n", + " -3.500000\n", " \n", " \n", " 335517\n", @@ -1024,7 +1045,7 @@ " 2\n", " 9\n", " 2\n", - " -3.922613\n", + " -3.500000\n", " \n", " \n", " 335519\n", @@ -1046,7 +1067,7 @@ " 2\n", " 2\n", " 2\n", - " -3.991597\n", + " -3.500000\n", " \n", " \n", "\n", @@ -1087,16 +1108,16 @@ "3 2 0 22495 0.000000 \n", "4 1 0 21020 0.000000 \n", "... ... ... ... ... \n", - "335513 2 5 1 -6.693818 \n", - "335514 2 3 1 -6.537503 \n", - "335517 2 9 2 -3.922613 \n", + "335513 2 5 1 -3.500000 \n", + "335514 2 3 1 -3.500000 \n", + "335517 2 9 2 -3.500000 \n", "335519 2 9 2 -3.160077 \n", - "335521 2 2 2 -3.991597 \n", + "335521 2 2 2 -3.500000 \n", "\n", "[295757 rows x 8 columns]" ] }, - "execution_count": 9, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -1114,12 +1135,24 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jgallowa/mambaforge/envs/multidms-dev/lib/python3.11/site-packages/seaborn/_base.py:948: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n", + " data_subset = grouped_data.get_group(pd_key)\n", + "/home/jgallowa/mambaforge/envs/multidms-dev/lib/python3.11/site-packages/seaborn/_base.py:948: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n", + " data_subset = grouped_data.get_group(pd_key)\n", + "/home/jgallowa/mambaforge/envs/multidms-dev/lib/python3.11/site-packages/seaborn/_base.py:948: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n", + " data_subset = grouped_data.get_group(pd_key)\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1150,12 +1183,12 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtEAAAEqCAYAAADTdAxAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAx8klEQVR4nO3de3xNd77/8fdONBcqcYncKkhLXVpkBGmmpVTGdhkdPdpBtUKVYcIgRaQlaDsnHUrRqox23FpOVc/QM9GmjdTlVOLSKEpxMC7tsENLsisqSNbvj3lYP7uCrEiyE3k9H4/1GGt9P+u7Pnt/J+bdNSurNsMwDAEAAAAoMQ93NwAAAABUNYRoAAAAwCJCNAAAAGARIRoAAACwiBANAAAAWESIBgAAACwiRAMAAAAW1XB3A9VJUVGRTp48qdq1a8tms7m7HQAAAPyCYRj66aefFBoaKg+PG99vJkRXoJMnTyosLMzdbQAAAOAWvvvuOzVs2PCG44ToClS7dm1J/14UPz8/N3cDAACAX3I6nQoLCzNz240QoivQ1Uc4/Pz8CNEAAACV2K0eveUXCwEAAACLCNEAAACARYRoAAAAwCJCNAAAAGARIRoAAACwiBANAAAAWESIBgAAACwiRAMAAAAW8S9bQZUSOXF5ucybPWtwucwLAADuTNyJBgAAACwiRAMAAAAWEaIBAAAAiwjRAAAAgEWEaAAAAMAiQjQAAABgESEaAAAAsIgQDQAAAFhEiAYAAAAsIkQDAAAAFhGiAQAAAIsI0QAAAIBFhGgAAADAIkI0AAAAYJFbQ/TmzZvVp08fhYaGymazae3atS7jQ4YMkc1mc9l69OjhUnP27FkNGjRIfn5+qlOnjoYNG6bz58+71OzZs0edOnWSj4+PwsLCNHPmzOt6Wb16tVq0aCEfHx+1bt1an3zyicu4YRhKSkpSSEiIfH19FRMTo0OHDpXNFwEAAIAqxa0hOj8/X23bttWCBQtuWNOjRw+dOnXK3P7rv/7LZXzQoEHat2+f0tPTlZqaqs2bN2vEiBHmuNPpVPfu3dW4cWNlZ2dr1qxZmj59uhYtWmTWZGZmauDAgRo2bJi+/vpr9e3bV3379tXevXvNmpkzZ2r+/PlKSUnRtm3bVKtWLdntdl28eLEMvxEAAABUBTbDMAx3NyFJNptNa9asUd++fc1jQ4YMUW5u7nV3qK/av3+/WrVqpR07dqh9+/aSpLS0NPXq1Uvff/+9QkNDtXDhQr300ktyOBzy8vKSJE2ePFlr167VgQMHJEn9+/dXfn6+UlNTzbkfeughRUREKCUlRYZhKDQ0VC+88IImTJggScrLy1NQUJCWLl2qAQMGlOgzOp1O+fv7Ky8vT35+fla/IkiKnLi8XObNnjW4XOYFAABVS0nzWqV/Jnrjxo0KDAxU8+bNNWrUKP3444/mWFZWlurUqWMGaEmKiYmRh4eHtm3bZtZ07tzZDNCSZLfbdfDgQZ07d86siYmJcbmu3W5XVlaWJOno0aNyOBwuNf7+/oqKijJrilNQUCCn0+myAQAAoOqr1CG6R48eWr58uTIyMvSXv/xFmzZtUs+ePVVYWChJcjgcCgwMdDmnRo0aqlevnhwOh1kTFBTkUnN1/1Y1145fe15xNcVJTk6Wv7+/uYWFhVn6/AAAAKicari7gZu59jGJ1q1bq02bNrrvvvu0ceNGdevWzY2dlUxiYqLi4+PNfafTSZAGAAC4A1TqO9G/dO+99yogIECHDx+WJAUHB+v06dMuNVeuXNHZs2cVHBxs1uTk5LjUXN2/Vc2149eeV1xNcby9veXn5+eyAQAAoOqrUiH6+++/148//qiQkBBJUnR0tHJzc5WdnW3WfPHFFyoqKlJUVJRZs3nzZl2+fNmsSU9PV/PmzVW3bl2zJiMjw+Va6enpio6OliSFh4crODjYpcbpdGrbtm1mDQAAAKoPt4bo8+fPa9euXdq1a5ekf/8C365du3TixAmdP39eEydO1NatW3Xs2DFlZGTod7/7nZo2bSq73S5JatmypXr06KHhw4dr+/bt2rJli0aPHq0BAwYoNDRUkvT000/Ly8tLw4YN0759+7Rq1SrNmzfP5TGLsWPHKi0tTbNnz9aBAwc0ffp0ffXVVxo9erSkf785ZNy4cXr11Vf1P//zP/rmm280ePBghYaGurxNBAAAANWDW5+J/uqrr9S1a1dz/2qwjY2N1cKFC7Vnzx4tW7ZMubm5Cg0NVffu3fXKK6/I29vbPGfFihUaPXq0unXrJg8PD/Xr10/z5883x/39/fX5558rLi5OkZGRCggIUFJSksu7pH/9619r5cqVmjJlil588UU1a9ZMa9eu1YMPPmjWTJo0Sfn5+RoxYoRyc3P1yCOPKC0tTT4+PuX5FQEAAKASqjTvia4OeE/07eM90QAAoDzdMe+JBgAAACobQjQAAABgESEaAAAAsIgQDQAAAFhEiAYAAAAsIkQDAAAAFhGiAQAAAIsI0QAAAIBFhGgAAADAIkI0AAAAYBEhGgAAALCIEA0AAABYRIgGAAAALCJEAwAAABYRogEAAACLCNEAAACARYRoAAAAwCJCNAAAAGARIRoAAACwiBANAAAAWESIBgAAACwiRAMAAAAWEaIBAAAAi9waojdv3qw+ffooNDRUNptNa9euNccuX76shIQEtW7dWrVq1VJoaKgGDx6skydPuszRpEkT2Ww2l+21115zqdmzZ486deokHx8fhYWFaebMmdf1snr1arVo0UI+Pj5q3bq1PvnkE5dxwzCUlJSkkJAQ+fr6KiYmRocOHSq7LwMAAABVhltDdH5+vtq2basFCxZcN3bhwgXt3LlTU6dO1c6dO/X3v/9dBw8e1OOPP35d7csvv6xTp06Z25gxY8wxp9Op7t27q3HjxsrOztasWbM0ffp0LVq0yKzJzMzUwIEDNWzYMH399dfq27ev+vbtq71795o1M2fO1Pz585WSkqJt27apVq1astvtunjxYhl/KwAAAKjsbIZhGO5uQpJsNpvWrFmjvn373rBmx44d6tixo44fP65GjRpJ+ved6HHjxmncuHHFnrNw4UK99NJLcjgc8vLykiRNnjxZa9eu1YEDByRJ/fv3V35+vlJTU83zHnroIUVERCglJUWGYSg0NFQvvPCCJkyYIEnKy8tTUFCQli5dqgEDBpToMzqdTvn7+ysvL09+fn4lOgeuIicuL5d5s2cNLpd5AQBA1VLSvFalnonOy8uTzWZTnTp1XI6/9tprql+/vn71q19p1qxZunLlijmWlZWlzp07mwFakux2uw4ePKhz586ZNTExMS5z2u12ZWVlSZKOHj0qh8PhUuPv76+oqCizpjgFBQVyOp0uGwAAAKq+Gu5uoKQuXryohIQEDRw40OWfCv70pz+pXbt2qlevnjIzM5WYmKhTp05pzpw5kiSHw6Hw8HCXuYKCgsyxunXryuFwmMeurXE4HGbdtecVV1Oc5ORkzZgxo5SfGAAAAJVVlQjRly9f1u9//3sZhqGFCxe6jMXHx5t/btOmjby8vPSHP/xBycnJ8vb2ruhWXSQmJrr053Q6FRYW5saOAAAAUBYq/eMcVwP08ePHlZ6efstniaOionTlyhUdO3ZMkhQcHKycnByXmqv7wcHBN625dvza84qrKY63t7f8/PxcNgAAAFR9lTpEXw3Qhw4d0vr161W/fv1bnrNr1y55eHgoMDBQkhQdHa3Nmzfr8uXLZk16erqaN2+uunXrmjUZGRku86Snpys6OlqSFB4eruDgYJcap9Opbdu2mTUAAACoPtz6OMf58+d1+PBhc//o0aPatWuX6tWrp5CQED355JPauXOnUlNTVVhYaD5/XK9ePXl5eSkrK0vbtm1T165dVbt2bWVlZWn8+PF65plnzID89NNPa8aMGRo2bJgSEhK0d+9ezZs3T2+88YZ53bFjx+rRRx/V7Nmz1bt3b33wwQf66quvzNfg2Ww2jRs3Tq+++qqaNWum8PBwTZ06VaGhoTd9mwgAAADuTG59xd3GjRvVtWvX647HxsZq+vTp1/1C4FUbNmxQly5dtHPnTv3xj3/UgQMHVFBQoPDwcD377LOKj493eR56z549iouL044dOxQQEKAxY8YoISHBZc7Vq1drypQpOnbsmJo1a6aZM2eqV69e5rhhGJo2bZoWLVqk3NxcPfLII3r77bd1//33l/jz8oq728cr7gAAQHkqaV6rNO+Jrg4I0bePEA0AAMrTHfmeaAAAAKAyIEQDAAAAFhGiAQAAAIsI0QAAAIBFhGgAAADAIkI0AAAAYBEhGgAAALCIEA0AAABYRIgGAAAALCJEAwAAABYRogEAAACLari7AZSvyInL3d2CZdmzBru7BQAAgJviTjQAAABgESEaAAAAsIgQDQAAAFhEiAYAAAAsIkQDAAAAFhGiAQAAAIsI0QAAAIBFhGgAAADAIkI0AAAAYBEhGgAAALDIrSF68+bN6tOnj0JDQ2Wz2bR27VqXccMwlJSUpJCQEPn6+iomJkaHDh1yqTl79qwGDRokPz8/1alTR8OGDdP58+ddavbs2aNOnTrJx8dHYWFhmjlz5nW9rF69Wi1atJCPj49at26tTz75xHIvAAAAqB7cGqLz8/PVtm1bLViwoNjxmTNnav78+UpJSdG2bdtUq1Yt2e12Xbx40awZNGiQ9u3bp/T0dKWmpmrz5s0aMWKEOe50OtW9e3c1btxY2dnZmjVrlqZPn65FixaZNZmZmRo4cKCGDRumr7/+Wn379lXfvn21d+9eS70AAACgerAZhmG4uwlJstlsWrNmjfr27Svp33d+Q0ND9cILL2jChAmSpLy8PAUFBWnp0qUaMGCA9u/fr1atWmnHjh1q3769JCktLU29evXS999/r9DQUC1cuFAvvfSSHA6HvLy8JEmTJ0/W2rVrdeDAAUlS//79lZ+fr9TUVLOfhx56SBEREUpJSSlRLyXhdDrl7++vvLw8+fn5lcn3diuRE5dXyHXKUvaswTccK6/Pc7NrAgCA6qOkea3SPhN99OhRORwOxcTEmMf8/f0VFRWlrKwsSVJWVpbq1KljBmhJiomJkYeHh7Zt22bWdO7c2QzQkmS323Xw4EGdO3fOrLn2Oldrrl6nJL0Up6CgQE6n02UDAABA1VdpQ7TD4ZAkBQUFuRwPCgoyxxwOhwIDA13Ga9SooXr16rnUFDfHtde4Uc2147fqpTjJycny9/c3t7CwsFt8agAAAFQFlTZE3wkSExOVl5dnbt999527WwIAAEAZKFWIfuyxx5Sbm3vdcafTqccee+x2e5IkBQcHS5JycnJcjufk5JhjwcHBOn36tMv4lStXdPbsWZea4ua49ho3qrl2/Fa9FMfb21t+fn4uGwAAAKq+UoXojRs36tKlS9cdv3jxov73f//3tpuSpPDwcAUHBysjI8M85nQ6tW3bNkVHR0uSoqOjlZubq+zsbLPmiy++UFFRkaKiosyazZs36/Lly2ZNenq6mjdvrrp165o1117nas3V65SkFwAAAFQfNawU79mzx/zzt99+6/I8cGFhodLS0nTPPfeUeL7z58/r8OHD5v7Ro0e1a9cu1atXT40aNdK4ceP06quvqlmzZgoPD9fUqVMVGhpqvsGjZcuW6tGjh4YPH66UlBRdvnxZo0eP1oABAxQaGipJevrppzVjxgwNGzZMCQkJ2rt3r+bNm6c33njDvO7YsWP16KOPavbs2erdu7c++OADffXVV+Zr8Gw22y17AQAAQPVhKURHRETIZrPJZrMV+9iGr6+v3nzzzRLP99VXX6lr167mfnx8vCQpNjZWS5cu1aRJk5Sfn68RI0YoNzdXjzzyiNLS0uTj42Oes2LFCo0ePVrdunWTh4eH+vXrp/nz55vj/v7++vzzzxUXF6fIyEgFBAQoKSnJ5V3Sv/71r7Vy5UpNmTJFL774opo1a6a1a9fqwQcfNGtK0gsAAACqB0vviT5+/LgMw9C9996r7du3q0GDBuaYl5eXAgMD5enpWS6N3gl4T3TJ8J5oAADgLiXNa5buRDdu3FiSVFRUdHvdAQAAAFWYpRB9rUOHDmnDhg06ffr0daE6KSnpthsDAAAAKqtSheh33nlHo0aNUkBAgIKDg2Wz2cwxm81GiAYAAMAdrVQh+tVXX9Wf//xnJSQklHU/AAAAQKVXqvdEnzt3Tk899VRZ9wIAAABUCaUK0U899ZQ+//zzsu4FAAAAqBJK9ThH06ZNNXXqVG3dulWtW7fWXXfd5TL+pz/9qUyaAwAAACqjUoXoRYsW6e6779amTZu0adMmlzGbzUaIBgAAwB2tVCH66NGjZd0HAAAAUGWU6ploAAAAoDor1Z3o55577qbjixcvLlUzAAAAQFVQqhB97tw5l/3Lly9r7969ys3N1WOPPVYmjQEAAACVValC9Jo1a647VlRUpFGjRum+++677aYAAACAyqzMnon28PBQfHy83njjjbKaEgAAAKiUyvQXC48cOaIrV66U5ZQAAABApVOqxzni4+Nd9g3D0KlTp7Ru3TrFxsaWSWMAAABAZVWqEP3111+77Ht4eKhBgwaaPXv2Ld/cAQAAAFR1pQrRGzZsKOs+AAAAgCqjVCH6qjNnzujgwYOSpObNm6tBgwZl0hQAAABQmZXqFwvz8/P13HPPKSQkRJ07d1bnzp0VGhqqYcOG6cKFC2XdIwAAAFCplCpEx8fHa9OmTfrHP/6h3Nxc5ebm6uOPP9amTZv0wgsvlHWPAAAAQKVSqsc5/vu//1sfffSRunTpYh7r1auXfH199fvf/14LFy4sq/4AAACASqdUd6IvXLigoKCg644HBgbyOAcAAADueKUK0dHR0Zo2bZouXrxoHvv55581Y8YMRUdHl1lzktSkSRPZbLbrtri4OElSly5drhsbOXKkyxwnTpxQ7969VbNmTQUGBmrixInX/UthNm7cqHbt2snb21tNmzbV0qVLr+tlwYIFatKkiXx8fBQVFaXt27eX6WcFAABA1VCqxznmzp2rHj16qGHDhmrbtq0kaffu3fL29tbnn39epg3u2LFDhYWF5v7evXv1m9/8Rk899ZR5bPjw4Xr55ZfN/Zo1a5p/LiwsVO/evRUcHKzMzEydOnVKgwcP1l133aX//M//lCQdPXpUvXv31siRI7VixQplZGTo+eefV0hIiOx2uyRp1apVio+PV0pKiqKiojR37lzZ7XYdPHhQgYGBZfqZAQAAULnZDMMwSnPihQsXtGLFCh04cECS1LJlSw0aNEi+vr5l2uAvjRs3TqmpqTp06JBsNpu6dOmiiIgIzZ07t9j6Tz/9VL/97W918uRJ8xGUlJQUJSQk6MyZM/Ly8lJCQoLWrVunvXv3mucNGDBAubm5SktLkyRFRUWpQ4cOeuuttyRJRUVFCgsL05gxYzR58uQS9e50OuXv76+8vDz5+fndxrdQcpETl1fIdcpS9qzBNxwrr89zs2sCAIDqo6R5rVR3opOTkxUUFKThw4e7HF+8eLHOnDmjhISE0kx7S5cuXdL777+v+Ph42Ww28/iKFSv0/vvvKzg4WH369NHUqVPNu9FZWVlq3bq1yzPcdrtdo0aN0r59+/SrX/1KWVlZiomJcbmW3W7XuHHjzOtmZ2crMTHRHPfw8FBMTIyysrJu2G9BQYEKCgrMfafTeVufHwAAAJVDqZ6J/utf/6oWLVpcd/yBBx5QSkrKbTd1I2vXrlVubq6GDBliHnv66af1/vvva8OGDUpMTNR7772nZ555xhx3OBzX/RLk1X2Hw3HTGqfTqZ9//lk//PCDCgsLi625OkdxkpOT5e/vb25hYWGl+twAAACoXEp1J9rhcCgkJOS64w0aNNCpU6duu6kb+dvf/qaePXsqNDTUPDZixAjzz61bt1ZISIi6deumI0eO6L777iu3XkoiMTFR8fHx5r7T6SRIAwAA3AFKdSc6LCxMW7Zsue74li1bXAJuWTp+/LjWr1+v559//qZ1UVFRkqTDhw9LkoKDg5WTk+NSc3U/ODj4pjV+fn7y9fVVQECAPD09i625OkdxvL295efn57IBAACg6itViB4+fLjGjRunJUuW6Pjx4zp+/LgWL16s8ePHX/ecdFlZsmSJAgMD1bt375vW7dq1S5LMO+XR0dH65ptvdPr0abMmPT1dfn5+atWqlVmTkZHhMk96err5uj4vLy9FRka61BQVFSkjI6PMX+kHAACAyq9Uj3NMnDhRP/74o/74xz/q0qVLkiQfHx8lJCS4/PJdWSkqKtKSJUsUGxurGjX+f8tHjhzRypUr1atXL9WvX1979uzR+PHj1blzZ7Vp00aS1L17d7Vq1UrPPvusZs6cKYfDoSlTpiguLk7e3t6SpJEjR+qtt97SpEmT9Nxzz+mLL77Qhx9+qHXr1pnXio+PV2xsrNq3b6+OHTtq7ty5ys/P19ChQ8v88wIAAKByK1WIttls+stf/qKpU6dq//798vX1VbNmzcxQWtbWr1+vEydO6LnnnnM57uXlpfXr15uBNiwsTP369dOUKVPMGk9PT6WmpmrUqFGKjo5WrVq1FBsb6/Je6fDwcK1bt07jx4/XvHnz1LBhQ7377rvmO6IlqX///jpz5oySkpLkcDgUERGhtLS0Yv/NjQAAALizlfo90bCO90SXDO+JBgAA7lLSvFaqZ6IBAACA6owQDQAAAFhEiAYAAAAsIkQDAAAAFhGiAQAAAIsI0QAAAIBFhGgAAADAIkI0AAAAYBEhGgAAALCIEA0AAABYRIgGAAAALCJEAwAAABYRogEAAACLCNEAAACARYRoAAAAwCJCNAAAAGARIRoAAACwiBANAAAAWESIBgAAACwiRAMAAAAWEaIBAAAAiwjRAAAAgEWVOkRPnz5dNpvNZWvRooU5fvHiRcXFxal+/fq6++671a9fP+Xk5LjMceLECfXu3Vs1a9ZUYGCgJk6cqCtXrrjUbNy4Ue3atZO3t7eaNm2qpUuXXtfLggUL1KRJE/n4+CgqKkrbt28vl88MAACAyq9Sh2hJeuCBB3Tq1Clz+/LLL82x8ePH6x//+IdWr16tTZs26eTJk/qP//gPc7ywsFC9e/fWpUuXlJmZqWXLlmnp0qVKSkoya44eParevXura9eu2rVrl8aNG6fnn39en332mVmzatUqxcfHa9q0adq5c6fatm0ru92u06dPV8yXAAAAgEql0ofoGjVqKDg42NwCAgIkSXl5efrb3/6mOXPm6LHHHlNkZKSWLFmizMxMbd26VZL0+eef69tvv9X777+viIgI9ezZU6+88ooWLFigS5cuSZJSUlIUHh6u2bNnq2XLlho9erSefPJJvfHGG2YPc+bM0fDhwzV06FC1atVKKSkpqlmzphYvXlzxXwgAAADcrtKH6EOHDik0NFT33nuvBg0apBMnTkiSsrOzdfnyZcXExJi1LVq0UKNGjZSVlSVJysrKUuvWrRUUFGTW2O12OZ1O7du3z6y5do6rNVfnuHTpkrKzs11qPDw8FBMTY9bcSEFBgZxOp8sGAACAqq9Sh+ioqCgtXbpUaWlpWrhwoY4ePapOnTrpp59+ksPhkJeXl+rUqeNyTlBQkBwOhyTJ4XC4BOir41fHblbjdDr1888/64cfflBhYWGxNVfnuJHk5GT5+/ubW1hYmOXvAAAAAJVPDXc3cDM9e/Y0/9ymTRtFRUWpcePG+vDDD+Xr6+vGzkomMTFR8fHx5r7T6SRIAwAA3AEq9Z3oX6pTp47uv/9+HT58WMHBwbp06ZJyc3NdanJychQcHCxJCg4Ovu5tHVf3b1Xj5+cnX19fBQQEyNPTs9iaq3PciLe3t/z8/Fw2AAAAVH1VKkSfP39eR44cUUhIiCIjI3XXXXcpIyPDHD948KBOnDih6OhoSVJ0dLS++eYbl7dopKeny8/PT61atTJrrp3jas3VOby8vBQZGelSU1RUpIyMDLMGAAAA1UulDtETJkzQpk2bdOzYMWVmZuqJJ56Qp6enBg4cKH9/fw0bNkzx8fHasGGDsrOzNXToUEVHR+uhhx6SJHXv3l2tWrXSs88+q927d+uzzz7TlClTFBcXJ29vb0nSyJEj9c9//lOTJk3SgQMH9Pbbb+vDDz/U+PHjzT7i4+P1zjvvaNmyZdq/f79GjRql/Px8DR061C3fCwAAANyrUj8T/f3332vgwIH68ccf1aBBAz3yyCPaunWrGjRoIEl644035OHhoX79+qmgoEB2u11vv/22eb6np6dSU1M1atQoRUdHq1atWoqNjdXLL79s1oSHh2vdunUaP3685s2bp4YNG+rdd9+V3W43a/r3768zZ84oKSlJDodDERERSktLu+6XDQEAAFA92AzDMNzdRHXhdDrl7++vvLy8Cns+OnLi8gq5TlnKnjX4hmPl9Xludk0AAFB9lDSvVerHOQAAAIDKiBANAAAAWESIBgAAACwiRAMAAAAWEaIBAAAAiwjRAAAAgEWEaAAAAMAiQjQAAABgESEaAAAAsIgQDQAAAFhEiAYAAAAsIkQDAAAAFhGiAQAAAIsI0QAAAIBFhGgAAADAIkI0AAAAYBEhGgAAALCIEA0AAABYRIgGAAAALCJEAwAAABYRogEAAACLCNEAAACARYRoAAAAwKJKHaKTk5PVoUMH1a5dW4GBgerbt68OHjzoUtOlSxfZbDaXbeTIkS41J06cUO/evVWzZk0FBgZq4sSJunLlikvNxo0b1a5dO3l7e6tp06ZaunTpdf0sWLBATZo0kY+Pj6KiorR9+/Yy/8wAAACo/Cp1iN60aZPi4uK0detWpaen6/Lly+revbvy8/Nd6oYPH65Tp06Z28yZM82xwsJC9e7dW5cuXVJmZqaWLVumpUuXKikpyaw5evSoevfura5du2rXrl0aN26cnn/+eX322WdmzapVqxQfH69p06Zp586datu2rex2u06fPl3+XwQAAAAqFZthGIa7myipM2fOKDAwUJs2bVLnzp0l/ftOdEREhObOnVvsOZ9++ql++9vf6uTJkwoKCpIkpaSkKCEhQWfOnJGXl5cSEhK0bt067d271zxvwIABys3NVVpamiQpKipKHTp00FtvvSVJKioqUlhYmMaMGaPJkyeXqH+n0yl/f3/l5eXJz8+vtF+DJZETl1fIdcpS9qzBNxwrr89zs2sCAIDqo6R5rVLfif6lvLw8SVK9evVcjq9YsUIBAQF68MEHlZiYqAsXLphjWVlZat26tRmgJclut8vpdGrfvn1mTUxMjMucdrtdWVlZkqRLly4pOzvbpcbDw0MxMTFmTXEKCgrkdDpdNgAAAFR9NdzdQEkVFRVp3Lhxevjhh/Xggw+ax59++mk1btxYoaGh2rNnjxISEnTw4EH9/e9/lyQ5HA6XAC3J3Hc4HDetcTqd+vnnn3Xu3DkVFhYWW3PgwIEb9pycnKwZM2aU/kMDAACgUqoyITouLk579+7Vl19+6XJ8xIgR5p9bt26tkJAQdevWTUeOHNF9991X0W26SExMVHx8vLnvdDoVFhbmxo4AAABQFqpEiB49erRSU1O1efNmNWzY8Ka1UVFRkqTDhw/rvvvuU3Bw8HVv0cjJyZEkBQcHm/959di1NX5+fvL19ZWnp6c8PT2Lrbk6R3G8vb3l7e1dsg8JAACAKqNSPxNtGIZGjx6tNWvW6IsvvlB4ePgtz9m1a5ckKSQkRJIUHR2tb775xuUtGunp6fLz81OrVq3MmoyMDJd50tPTFR0dLUny8vJSZGSkS01RUZEyMjLMGgAAAFQflfpOdFxcnFauXKmPP/5YtWvXNp9h9vf3l6+vr44cOaKVK1eqV69eql+/vvbs2aPx48erc+fOatOmjSSpe/fuatWqlZ599lnNnDlTDodDU6ZMUVxcnHmXeOTIkXrrrbc0adIkPffcc/riiy/04Ycfat26dWYv8fHxio2NVfv27dWxY0fNnTtX+fn5Gjp0aMV/MQAAAHCrSh2iFy5cKOnfr7G71pIlSzRkyBB5eXlp/fr1ZqANCwtTv379NGXKFLPW09NTqampGjVqlKKjo1WrVi3Fxsbq5ZdfNmvCw8O1bt06jR8/XvPmzVPDhg317rvvym63mzX9+/fXmTNnlJSUJIfDoYiICKWlpV33y4YAAAC481Wp90RXdbwnumR4TzQAAHCXO/I90QAAAEBlQIgGAAAALCJEAwAAABYRogEAAACLCNEAAACARYRoAAAAwCJCNAAAAGARIRoAAACwiBANAAAAWESIBgAAACwiRAMAAAAWEaIBAAAAiwjRAAAAgEWEaAAAAMAiQjQAAABgESEaAAAAsIgQDQAAAFhEiAYAAAAsquHuBoA7VeTE5SWuzZ41uBw7AQAAZY070QAAAIBFhGgAAADAIkI0AAAAYBHPRFu0YMECzZo1Sw6HQ23bttWbb76pjh07urstVEM3e+aaZ6wBAChfhGgLVq1apfj4eKWkpCgqKkpz586V3W7XwYMHFRgY6O72AEuKC+GEbwAASoYQbcGcOXM0fPhwDR06VJKUkpKidevWafHixZo8ebKbu0NZsvJmjWvdySGU0A0AwP9HiC6hS5cuKTs7W4mJieYxDw8PxcTEKCsrq9hzCgoKVFBQYO7n5eVJkpxOZ/k2e43Cgp8r7Fpl5WbfT3l9nl9es7TXuXYeK3NcPa/zlP+6Ze3mVwfecv5bzbf51YHFnm/1uy+u/pfXvNrvjWqKGwcAwF2u/m+bYRg3rbMZt6qAJOnkyZO65557lJmZqejoaPP4pEmTtGnTJm3btu26c6ZPn64ZM2ZUZJsAAAAoA999950aNmx4w3HuRJejxMRExcfHm/tFRUU6e/as6tevL5vNdl19hw4dtGPHjhLNXdLaW9XdbNzKmNPpVFhYmL777jv5+fndsq+KYuU7rah5rZ5bkvrbrbnRWHHHK+NaV5d1LkndnbzOUvms9e3O6Y6faf7urvh5+ZkuH5XtZ7pDhw7avn27fvrpJ4WGht60lhBdQgEBAfL09FROTo7L8ZycHAUHBxd7jre3t7y9vV2O1alT54bX8PT0LPF/sUtae6u6m42XZszPz69S/XBa+U4ral6r55ak/nZrbjR2s3Mq01pXl3UuSd2dvM5S+az17c7pjp9p/u6u+Hn5mS4fle1n2tPTU/7+/vL3979lLe+JLiEvLy9FRkYqIyPDPFZUVKSMjAyXxztuR1xcXJnX3qruZuOlHatMyqvP25nX6rklqb/dmhuNsc6Va51LUncnr7NUPr3e7pzu+Jnm7+6Kn5ef6fJR2X6mrZzLM9EWrFq1SrGxsfrrX/+qjh07au7cufrwww914MABBQUFubs9t3I6nfL391deXl6l+idclD3WunpgnasH1rn6YK3LHo9zWNC/f3+dOXNGSUlJcjgcioiIUFpaWrUP0NK/H12ZNm3adY+v4M7DWlcPrHP1wDpXH6x12eNONAAAAGARz0QDAAAAFhGiAQAAAIsI0QAAAIBFhGgAAADAIkI0AAAAYBEhGhUiNTVVzZs3V7NmzfTuu++6ux2UkyeeeEJ169bVk08+6e5WUE6+++47denSRa1atVKbNm20evVqd7eEcpKbm6v27dsrIiJCDz74oN555x13t4RydOHCBTVu3FgTJkxwdytVBq+4Q7m7cuWKWrVqpQ0bNsjf31+RkZHKzMxU/fr13d0aytjGjRv1008/admyZfroo4/c3Q7KwalTp5STk6OIiAg5HA5FRkbq//7v/1SrVi13t4YyVlhYqIKCAtWsWVP5+fl68MEH9dVXX/F39x3qpZde0uHDhxUWFqbXX3/d3e1UCdyJRrnbvn27HnjgAd1zzz26++671bNnT33++efubgvloEuXLqpdu7a720A5CgkJUUREhCQpODhYAQEBOnv2rHubQrnw9PRUzZo1JUkFBQUyDEPcd7szHTp0SAcOHFDPnj3d3UqVQojGLW3evFl9+vRRaGiobDab1q5de13NggUL1KRJE/n4+CgqKkrbt283x06ePKl77rnH3L/nnnv0r3/9qyJahwW3u86oGspynbOzs1VYWKiwsLBy7hqlURZrnZubq7Zt26phw4aaOHGiAgICKqh7lFRZrPOECROUnJxcQR3fOQjRuKX8/Hy1bdtWCxYsKHZ81apVio+P17Rp07Rz5061bdtWdrtdp0+fruBOcTtY5+qhrNb57NmzGjx4sBYtWlQRbaMUymKt69Spo927d+vo0aNauXKlcnJyKqp9lNDtrvPHH3+s+++/X/fff39Ftn1nMAALJBlr1qxxOdaxY0cjLi7O3C8sLDRCQ0ON5ORkwzAMY8uWLUbfvn3N8bFjxxorVqyokH5ROqVZ56s2bNhg9OvXryLaxG0q7TpfvHjR6NSpk7F8+fKKahW36XZ+pq8aNWqUsXr16vJsE7epNOs8efJko2HDhkbjxo2N+vXrG35+fsaMGTMqsu0qizvRuC2XLl1Sdna2YmJizGMeHh6KiYlRVlaWJKljx47au3ev/vWvf+n8+fP69NNPZbfb3dUySqEk64yqryTrbBiGhgwZoscee0zPPvusu1rFbSrJWufk5Oinn36SJOXl5Wnz5s1q3ry5W/pF6ZRknZOTk/Xdd9/p2LFjev311zV8+HAlJSW5q+UqpYa7G0DV9sMPP6iwsFBBQUEux4OCgnTgwAFJUo0aNTR79mx17dpVRUVFmjRpEr/dXcWUZJ0lKSYmRrt371Z+fr4aNmyo1atXKzo6uqLbRSmVZJ23bNmiVatWqU2bNuazl++9955at25d0e3iNpRkrY8fP64RI0aYv1A4ZswY1rmKKenf3SgdQjQqxOOPP67HH3/c3W2gnK1fv97dLaCcPfLIIyoqKnJ3G6gAHTt21K5du9zdBirQkCFD3N1ClcLjHLgtAQEB8vT0vO6XTXJychQcHOymrlDWWOfqgXWuPljr6oF1Ll+EaNwWLy8vRUZGKiMjwzxWVFSkjIwM/m/8OwjrXD2wztUHa109sM7li8c5cEvnz5/X4cOHzf2jR49q165dqlevnho1aqT4+HjFxsaqffv26tixo+bOnav8/HwNHTrUjV3DKta5emCdqw/Wunpgnd3IzW8HQRWwYcMGQ9J1W2xsrFnz5ptvGo0aNTK8vLyMjh07Glu3bnVfwygV1rl6YJ2rD9a6emCd3cdmGPw7PAEAAAAreCYaAAAAsIgQDQAAAFhEiAYAAAAsIkQDAAAAFhGiAQAAAIsI0QAAAIBFhGgAAADAIkI0AAAAYBEhGgAAALCIEA0Ad4AuXbpo3Lhx7m6jRIYMGaK+ffu6uw0AuC2EaAAAAMAiQjQA4DqGYejKlSvubgMAKi1CNADcIa5cuaLRo0fL399fAQEBmjp1qgzDkCS99957at++vWrXrq3g4GA9/fTTOn36tHnuxo0bZbPZ9OmnnyoyMlLe3t768ssvVVRUpJkzZ6pp06by9vZWo0aN9Oc//9k875tvvtFjjz0mX19f1a9fXyNGjND58+fN8cLCQsXHx6tOnTqqX7++Jk2aZPZ0VVFRkZKTkxUeHi5fX1+1bdtWH330kTl+7tw5DRo0SA0aNJCvr6+aNWumJUuWlNfXCAAlQogGgDvEsmXLVKNGDW3fvl3z5s3TnDlz9O6770qSLl++rFdeeUW7d+/W2rVrdezYMQ0ZMuS6OSZPnqzXXntN+/fvV5s2bZSYmKjXXntNU6dO1bfffquVK1cqKChIkpSfny+73a66detqx44dWr16tdavX6/Ro0eb882ePVtLly7V4sWL9eWXX+rs2bNas2aNyzWTk5O1fPlypaSkaN++fRo/fryeeeYZbdq0SZLMa3/66afav3+/Fi5cqICAgHL6FgGghAwAQJX36KOPGi1btjSKiorMYwkJCUbLli2Lrd+xY4chyfjpp58MwzCMDRs2GJKMtWvXmjVOp9Pw9vY23nnnnWLnWLRokVG3bl3j/Pnz5rF169YZHh4ehsPhMAzDMEJCQoyZM2ea45cvXzYaNmxo/O53vzMMwzAuXrxo1KxZ08jMzHSZe9iwYcbAgQMNwzCMPn36GEOHDi3pVwEAFYI70QBwh3jooYdks9nM/ejoaB06dEiFhYXKzs5Wnz591KhRI9WuXVuPPvqoJOnEiRMuc7Rv39788/79+1VQUKBu3boVe739+/erbdu2qlWrlnns4YcfVlFRkQ4ePKi8vDydOnVKUVFR5niNGjVcrnH48GFduHBBv/nNb3T33Xeb2/Lly3XkyBFJ0qhRo/TBBx8oIiJCkyZNUmZm5m18SwBQNmq4uwEAQPm6ePGi7Ha77Ha7VqxYoQYNGujEiROy2+26dOmSS+21gdjX17fce7v6/PS6det0zz33uIx5e3tLknr27Knjx4/rk08+UXp6urp166a4uDi9/vrr5d4fANwId6IB4A6xbds2l/2tW7eqWbNmOnDggH788Ue99tpr6tSpk1q0aOHyS4U30qxZM/n6+iojI6PY8ZYtW2r37t3Kz883j23ZskUeHh5q3ry5/P39FRIS4tLXlStXlJ2dbe63atVK3t7eOnHihJo2beqyhYWFmXUNGjRQbGys3n//fc2dO1eLFi0q8fcCAOWBO9EAcIc4ceKE4uPj9Yc//EE7d+7Um2++qdmzZ6tRo0by8vLSm2++qZEjR2rv3r165ZVXbjmfj4+PEhISNGnSJHl5eenhhx/WmTNntG/fPg0bNkyDBg3StGnTFBsbq+nTp+vMmTMaM2aMnn32WfOXD8eOHavXXntNzZo1U4sWLTRnzhzl5uaa16hdu7YmTJig8ePHq6ioSI888ojy8vK0ZcsW+fn5KTY2VklJSYqMjNQDDzyggoICpaamqmXLluX1NQJAiRCiAeAOMXjwYP3888/q2LGjPD09NXbsWI0YMUI2m01Lly7Viy++qPnz56tdu3Z6/fXX9fjjj99yzqlTp6pGjRpKSkrSyZMnFRISopEjR0qSatasqc8++0xjx45Vhw4dVLNmTfXr109z5swxz3/hhRd06tQpxcbGysPDQ88995yeeOIJ5eXlmTWvvPKKGjRooOTkZP3zn/9UnTp11K5dO7344ouSJC8vLyUmJurYsWPy9fVVp06d9MEHH5TxtwcA1tgM4xcv7AQAAABwUzwTDQAAAFhEiAYAAAAsIkQDAAAAFhGiAQAAAIsI0QAAAIBFhGgAAADAIkI0AAAAYBEhGgAAALCIEA0AAABYRIgGAAAALCJEAwAAABb9Py5/aqCkFGLYAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -1181,12 +1214,12 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1210,7 +1243,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -1219,13 +1252,13 @@ "" ] }, - "execution_count": 13, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZsAAAEmCAYAAAC0zD1TAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAyQ0lEQVR4nO3de1wU9d4H8M8iLruiuwjILptIPGkCSZKgiJYnk1xSO1FUYKSkHD15wFTMu+Ili0LNy/FCelLsSZ/MejTDwghvpaSIkjdE7WBSusAJYQMVEH7PH72Yhw1UwB1B/Lxfr3m9Yn7fmfnOzjn7cXZndhRCCAEiIiIZ2TR3A0RE1PoxbIiISHYMGyIikh3DhoiIZMewISIi2TFsiIhIdgwbIiKSHcOGiIhkZ9vcDdxPqqurcenSJXTo0AEKhaK52yEiumNCCPz+++8wGAywsbn5+QvD5i66dOkS3NzcmrsNIiKry8vLQ+fOnW86zrC5izp06ADgj4Oi0WiauRsiojtnNpvh5uYmvb/dDMPmLqr56Eyj0TBsiKhVud1XA7xAgIiIZMewISIi2TFsiIhIdgwbIiKSHcOGiIhkx7AhIiLZMWyIiEh2zRo2+/fvx7PPPguDwQCFQoHt27dLY5WVlZg2bRp8fHxgb28Pg8GAkSNH4tKlSxbrKCoqQkREBDQaDRwcHBAVFYXS0lKLmuPHj+OJJ56ASqWCm5sbEhIS6vSydetWeHp6QqVSwcfHB1999ZXFuBACcXFxcHV1hVqtRlBQEM6dO2e9F4OIqBVr1ps6y8rK0LNnT4wePRovvPCCxdjVq1dx9OhRzJkzBz179sSVK1cwYcIE/PWvf8WRI0ekuoiICFy+fBmpqamorKzEqFGjMHbsWGzevBnAH3e3Dh48GEFBQUhMTMSJEycwevRoODg4YOzYsQCAgwcPYvjw4YiPj8ewYcOwefNmhISE4OjRo+jRowcAICEhAStWrMDGjRvh4eGBOXPmwGg04vTp01CpVHfpFaOWwm/KR83dQquQuWhkc7dAd4lCCCGauwngj7tPt23bhpCQkJvWZGRkoE+fPvj555/RpUsXZGdnw9vbGxkZGfD39wcApKSkYMiQIfjll19gMBiwZs0azJo1CyaTCUqlEgAwffp0bN++HWfOnAEAhIWFoaysDMnJydK2+vbtC19fXyQmJkIIAYPBgMmTJ+PNN98EAJSUlECn0yEpKQnh4eEN2kez2QytVouSkhL+gsA9jmFjHQybe19D39fuqe9sSkpKoFAo4ODgAABIT0+Hg4ODFDQAEBQUBBsbGxw6dEiqGTBggBQ0AGA0GpGTk4MrV65INUFBQRbbMhqNSE9PBwDk5ubCZDJZ1Gi1WgQEBEg19SkvL4fZbLaYiIjuR/dM2Fy/fh3Tpk3D8OHDpfQ0mUxwcXGxqLO1tYWjoyNMJpNUo9PpLGpq/r5dTe3x2svVV1Of+Ph4aLVaaeIvPhPR/eqeCJvKykq8/PLLEEJgzZo1zd1Og82YMQMlJSXSlJeX19wtERE1ixb/q881QfPzzz9j9+7dFp8J6vV6FBQUWNTfuHEDRUVF0Ov1Uk1+fr5FTc3ft6upPV4zz9XV1aLG19f3pr3b2dnBzs6uMbtLRNQqtegzm5qgOXfuHL799ls4OTlZjAcGBqK4uBiZmZnSvN27d6O6uhoBAQFSzf79+1FZWSnVpKamonv37ujYsaNUk5aWZrHu1NRUBAYGAgA8PDyg1+stasxmMw4dOiTVEBHRzTVr2JSWliIrKwtZWVkA/vgiPisrCxcvXkRlZSVefPFFHDlyBJs2bUJVVRVMJhNMJhMqKioAAF5eXggODsaYMWNw+PBhHDhwADExMQgPD4fBYAAAvPLKK1AqlYiKisKpU6ewZcsWLF++HLGxsVIfEyZMQEpKCpYsWYIzZ85g3rx5OHLkCGJiYgD8caXcxIkTsXDhQuzYsQMnTpzAyJEjYTAYbnn1HBER/aFZL33eu3cvBg4cWGd+ZGQk5s2bBw8Pj3qX27NnD5588kkAf9zUGRMTgy+//BI2NjYIDQ3FihUr0L59e6n++PHjiI6ORkZGBpydnTF+/HhMmzbNYp1bt27F7NmzceHCBXTr1g0JCQkYMmSINC6EwNy5c7F27VoUFxfj8ccfx+rVq/Hwww83eH956XPrwUufrYOXPt/7Gvq+1mLus7kfMGxaD4aNdTBs7n0NfV9r8RcIEBE1Bv8hYD3W/MdAi75AgIiIWgeGDRERyY5hQ0REsmPYEBGR7Bg2REQkO4YNERHJjmFDRESyY9gQEZHsGDZERCQ7hg0REcmOYUNERLJj2BARkewYNkREJDuGDRERyY5hQ0REsmPYEBGR7Bg2REQkO4YNERHJjmFDRESyY9gQEZHsGDZERCQ7hg0REcmOYUNERLJj2BARkeyaNWz279+PZ599FgaDAQqFAtu3b7cYF0IgLi4Orq6uUKvVCAoKwrlz5yxqioqKEBERAY1GAwcHB0RFRaG0tNSi5vjx43jiiSegUqng5uaGhISEOr1s3boVnp6eUKlU8PHxwVdffdXoXoiIqH7NGjZlZWXo2bMnVq1aVe94QkICVqxYgcTERBw6dAj29vYwGo24fv26VBMREYFTp04hNTUVycnJ2L9/P8aOHSuNm81mDB48GO7u7sjMzMSiRYswb948rF27Vqo5ePAghg8fjqioKBw7dgwhISEICQnByZMnG9ULERHVTyGEEM3dBAAoFAps27YNISEhAP44kzAYDJg8eTLefPNNAEBJSQl0Oh2SkpIQHh6O7OxseHt7IyMjA/7+/gCAlJQUDBkyBL/88gsMBgPWrFmDWbNmwWQyQalUAgCmT5+O7du348yZMwCAsLAwlJWVITk5Weqnb9++8PX1RWJiYoN6aQiz2QytVouSkhJoNBqrvG7UPPymfNTcLbQKmYtGWn2dPDbW05Dj09D3tRb7nU1ubi5MJhOCgoKkeVqtFgEBAUhPTwcApKenw8HBQQoaAAgKCoKNjQ0OHTok1QwYMEAKGgAwGo3IycnBlStXpJra26mpqdlOQ3qpT3l5Ocxms8VERHQ/arFhYzKZAAA6nc5ivk6nk8ZMJhNcXFwsxm1tbeHo6GhRU986am/jZjW1x2/XS33i4+Oh1Wqlyc3N7TZ7TUTUOrXYsGkNZsyYgZKSEmnKy8tr7paIiJpFiw0bvV4PAMjPz7eYn5+fL43p9XoUFBRYjN+4cQNFRUUWNfWto/Y2blZTe/x2vdTHzs4OGo3GYiIiuh+12LDx8PCAXq9HWlqaNM9sNuPQoUMIDAwEAAQGBqK4uBiZmZlSze7du1FdXY2AgACpZv/+/aisrJRqUlNT0b17d3Ts2FGqqb2dmpqa7TSkFyIiurlmDZvS0lJkZWUhKysLwB9fxGdlZeHixYtQKBSYOHEiFi5ciB07duDEiRMYOXIkDAaDdMWal5cXgoODMWbMGBw+fBgHDhxATEwMwsPDYTAYAACvvPIKlEoloqKicOrUKWzZsgXLly9HbGys1MeECROQkpKCJUuW4MyZM5g3bx6OHDmCmJgYAGhQL0REdHO2zbnxI0eOYODAgdLfNQEQGRmJpKQkTJ06FWVlZRg7diyKi4vx+OOPIyUlBSqVSlpm06ZNiImJwaBBg2BjY4PQ0FCsWLFCGtdqtfjmm28QHR0NPz8/ODs7Iy4uzuJenH79+mHz5s2YPXs2Zs6ciW7dumH79u3o0aOHVNOQXoiIqH4t5j6b+wHvs2k9eC+HdfA+m5btvrjPhoiIWg+GDRERyY5hQ0REsmPYEBGR7Bg2REQkO4YNERHJjmFDRESyY9gQEZHsGDZERCQ7hg0REcmOYUNERLJj2BARkewYNkREJDuGDRERyY5hQ0REsmPYEBGR7Bg2REQkO4YNERHJjmFDRESyY9gQEZHsGDZERCQ7hg0REcmOYUNERLJj2BARkewYNkREJLsWHTZVVVWYM2cOPDw8oFar8dBDD+Gtt96CEEKqEUIgLi4Orq6uUKvVCAoKwrlz5yzWU1RUhIiICGg0Gjg4OCAqKgqlpaUWNcePH8cTTzwBlUoFNzc3JCQk1Oln69at8PT0hEqlgo+PD7766it5dpyIqJVp0WHz3nvvYc2aNVi5ciWys7Px3nvvISEhAf/85z+lmoSEBKxYsQKJiYk4dOgQ7O3tYTQacf36dakmIiICp06dQmpqKpKTk7F//36MHTtWGjebzRg8eDDc3d2RmZmJRYsWYd68eVi7dq1Uc/DgQQwfPhxRUVE4duwYQkJCEBISgpMnT96dF4OI6B6mELVPE1qYYcOGQafT4cMPP5TmhYaGQq1W4+OPP4YQAgaDAZMnT8abb74JACgpKYFOp0NSUhLCw8ORnZ0Nb29vZGRkwN/fHwCQkpKCIUOG4JdffoHBYMCaNWswa9YsmEwmKJVKAMD06dOxfft2nDlzBgAQFhaGsrIyJCcnS7307dsXvr6+SExMbND+mM1maLValJSUQKPRWOU1oubhN+Wj5m6hVchcNNLq6+SxsZ6GHJ+Gvq+16DObfv36IS0tDWfPngUA/Pjjj/j+++/xzDPPAAByc3NhMpkQFBQkLaPVahEQEID09HQAQHp6OhwcHKSgAYCgoCDY2Njg0KFDUs2AAQOkoAEAo9GInJwcXLlyRaqpvZ2amprt1Ke8vBxms9liIiK6H9k2dwO3Mn36dJjNZnh6eqJNmzaoqqrC22+/jYiICACAyWQCAOh0OovldDqdNGYymeDi4mIxbmtrC0dHR4saDw+POuuoGevYsSNMJtMtt1Of+Ph4zJ8/v7G7TUTU6rToM5tPP/0UmzZtwubNm3H06FFs3LgRixcvxsaNG5u7tQaZMWMGSkpKpCkvL6+5WyIiahYt+sxmypQpmD59OsLDwwEAPj4++PnnnxEfH4/IyEjo9XoAQH5+PlxdXaXl8vPz4evrCwDQ6/UoKCiwWO+NGzdQVFQkLa/X65Gfn29RU/P37WpqxutjZ2cHOzu7xu42EVGr06LPbK5evQobG8sW27Rpg+rqagCAh4cH9Ho90tLSpHGz2YxDhw4hMDAQABAYGIji4mJkZmZKNbt370Z1dTUCAgKkmv3796OyslKqSU1NRffu3dGxY0eppvZ2ampqtkNERDfXosPm2Wefxdtvv42dO3fiwoUL2LZtG95//308//zzAACFQoGJEydi4cKF2LFjB06cOIGRI0fCYDAgJCQEAODl5YXg4GCMGTMGhw8fxoEDBxATE4Pw8HAYDAYAwCuvvAKlUomoqCicOnUKW7ZswfLlyxEbGyv1MmHCBKSkpGDJkiU4c+YM5s2bhyNHjiAmJuauvy5ERPeaFv0x2j//+U/MmTMH//jHP1BQUACDwYC///3viIuLk2qmTp2KsrIyjB07FsXFxXj88ceRkpIClUol1WzatAkxMTEYNGgQbGxsEBoaihUrVkjjWq0W33zzDaKjo+Hn5wdnZ2fExcVZ3IvTr18/bN68GbNnz8bMmTPRrVs3bN++HT169Lg7LwYR0T2sRd9n09rwPpvWg/dyWAfvs2nZ7pv7bIiIqHVg2BARkewYNkREJDuGDRERyY5hQ0REsmtS2Dz11FMoLi6uM99sNuOpp566056IiKiVaVLY7N27FxUVFXXmX79+Hd99990dN0VERK1Lo27qPH78uPTfp0+ftvjF46qqKqSkpOCBBx6wXndERNQqNCpsfH19oVAooFAo6v24TK1WWzxFk4iICGhk2OTm5kIIgf/6r//C4cOH0alTJ2lMqVTCxcUFbdq0sXqTRER0b2tU2Li7uwOA9KvLREREDdHkH+I8d+4c9uzZg4KCgjrhU/uHMomIiJoUNuvWrcO4cePg7OwMvV4PhUIhjSkUCoYNERFZaFLYLFy4EG+//TamTZtm7X6IiKgVatJ9NleuXMFLL71k7V6IiKiValLYvPTSS/jmm2+s3QsREbVSTfoYrWvXrpgzZw5++OEH+Pj4oG3bthbjb7zxhlWaIyKi1qFJYbN27Vq0b98e+/btw759+yzGFAoFw4aIiCw0KWxyc3Ot3QcREbVifMQAERHJrklnNqNHj77l+Pr165vUDBERtU5NCpsrV65Y/F1ZWYmTJ0+iuLiYz7MhIqI6mhQ227ZtqzOvuroa48aNw0MPPXTHTRERUetite9sbGxsEBsbi6VLl1prlURE1EpY9QKBn376CTdu3LDmKomIqBVoUtjExsZaTJMmTUJ4eDjCwsIQFhZm1QZ//fVXvPrqq3BycoJarYaPjw+OHDkijQshEBcXB1dXV6jVagQFBeHcuXMW6ygqKkJERAQ0Gg0cHBwQFRWF0tJSi5rjx4/jiSeegEqlgpubGxISEur0snXrVnh6ekKlUsHHxwdfffWVVfeViKi1alLYHDt2zGKqeVz0kiVLsGzZMqs1d+XKFfTv3x9t27bF119/jdOnT2PJkiXo2LGjVJOQkIAVK1YgMTERhw4dgr29PYxGI65fvy7VRERE4NSpU0hNTUVycjL279+PsWPHSuNmsxmDBw+Gu7s7MjMzsWjRIsybNw9r166Vag4ePIjhw4cjKioKx44dQ0hICEJCQnDy5Emr7S8RUWulEEKI5m7iZqZPn44DBw7gu+++q3dcCAGDwYDJkyfjzTffBACUlJRAp9MhKSkJ4eHhyM7Ohre3NzIyMuDv7w8ASElJwZAhQ/DLL7/AYDBgzZo1mDVrFkwmE5RKpbTt7du348yZMwCAsLAwlJWVITk5Wdp+37594evri8TExAbtj9lshlarRUlJCTQaTZNfF2p+flM+au4WWoXMRSOtvk4eG+tpyPFp6PvaHX1nU1hYiO+//x7ff/89CgsL72RV9dqxYwf8/f3x0ksvwcXFBY899hjWrVsnjefm5sJkMiEoKEiap9VqERAQgPT0dABAeno6HBwcpKABgKCgINjY2ODQoUNSzYABA6SgAQCj0YicnBzpMu/09HSL7dTU1GynPuXl5TCbzRYTEdH9qElhU1ZWhtGjR8PV1RUDBgzAgAEDYDAYEBUVhatXr1qtuX//+99Ys2YNunXrhl27dmHcuHF44403sHHjRgCAyWQCAOh0OovldDqdNGYymeDi4mIxbmtrC0dHR4ua+tZRexs3q6kZr098fDy0Wq00ubm5NWr/iYhaiyZfILBv3z58+eWXKC4uRnFxMb744gvs27cPkydPtlpz1dXV6NWrF9555x089thjGDt2LMaMGdPgj62a24wZM1BSUiJNeXl5zd0SEVGzaFLYfP755/jwww/xzDPPQKPRQKPRYMiQIVi3bh0+++wzqzXn6uoKb29vi3leXl64ePEiAECv1wMA8vPzLWry8/OlMb1ej4KCAovxGzduoKioyKKmvnXU3sbNamrG62NnZye9PjUTEdH9qElhc/Xq1TofKQGAi4uLVT9G69+/P3JycizmnT17Fu7u7gAADw8P6PV6pKWlSeNmsxmHDh1CYGAgACAwMBDFxcXIzMyUanbv3o3q6moEBARINfv370dlZaVUk5qaiu7du0tXvgUGBlpsp6amZjtERHRzTfq5msDAQMydOxcfffQRVCoVAODatWuYP3++Vd98J02ahH79+uGdd97Byy+/jMOHD2Pt2rXSJckKhQITJ07EwoUL0a1bN3h4eGDOnDkwGAwICQkB8MeZUHBwsPTxW2VlJWJiYhAeHg6DwQAAeOWVVzB//nxERUVh2rRpOHnyJJYvX27xawgTJkzAX/7yFyxZsgRDhw7FJ598giNHjlhcHm1NvKLGeuS44omIGqdJYbNs2TIEBwejc+fO6NmzJwDgxx9/hJ2dnVUfF927d29s27YNM2bMwIIFC+Dh4YFly5YhIiJCqpk6dSrKysowduxYFBcX4/HHH0dKSooUggCwadMmxMTEYNCgQbCxsUFoaChWrFghjWu1WnzzzTeIjo6Gn58fnJ2dERcXZ3EvTr9+/bB582bMnj0bM2fORLdu3bB9+3b06NHDavtLRNRaNfk+m6tXr2LTpk3SfSheXl6IiIiAWq22aoOtSWPus+GZjfXwXo6Wi8emZbPmfTZNOrOJj4+HTqfDmDFjLOavX78ehYWFmDZtWlNWS0RErVSTLhD44IMP4OnpWWf+I488cs9clkxERHdPk8LGZDLB1dW1zvxOnTrh8uXLd9wUERG1Lk0KGzc3Nxw4cKDO/AMHDkhXeBEREdVo0nc2Y8aMwcSJE1FZWSk9BjotLQ1Tp0616i8IEBFR69CksJkyZQp+++03/OMf/0BFRQUAQKVSYdq0aZgxY4ZVGyQiontfk8JGoVDgvffew5w5c5CdnQ21Wo1u3brBzs7O2v0REVEr0KSwqdG+fXv07t3bWr0QEVErdUfPsyEiImoIhg0REcmOYUNERLJj2BARkewYNkREJDuGDRERyY5hQ0REsmPYEBGR7Bg2REQkO4YNERHJjmFDRESyY9gQEZHsGDZERCQ7hg0REcmOYUNERLJj2BARkewYNkREJLt7KmzeffddKBQKTJw4UZp3/fp1REdHw8nJCe3bt0doaCjy8/Mtlrt48SKGDh2Kdu3awcXFBVOmTMGNGzcsavbu3YtevXrBzs4OXbt2RVJSUp3tr1q1Cg8++CBUKhUCAgJw+PBhOXaTiKjVuWfCJiMjAx988AEeffRRi/mTJk3Cl19+ia1bt2Lfvn24dOkSXnjhBWm8qqoKQ4cORUVFBQ4ePIiNGzciKSkJcXFxUk1ubi6GDh2KgQMHIisrCxMnTsTf/vY37Nq1S6rZsmULYmNjMXfuXBw9ehQ9e/aE0WhEQUGB/DtPRHSPuyfCprS0FBEREVi3bh06duwozS8pKcGHH36I999/H0899RT8/PywYcMGHDx4ED/88AMA4JtvvsHp06fx8ccfw9fXF8888wzeeustrFq1ChUVFQCAxMREeHh4YMmSJfDy8kJMTAxefPFFLF26VNrW+++/jzFjxmDUqFHw9vZGYmIi2rVrh/Xr19/dF4OI6B50T4RNdHQ0hg4diqCgIIv5mZmZqKystJjv6emJLl26ID09HQCQnp4OHx8f6HQ6qcZoNMJsNuPUqVNSzZ/XbTQapXVUVFQgMzPTosbGxgZBQUFSTX3Ky8thNpstJiKi+5FtczdwO5988gmOHj2KjIyMOmMmkwlKpRIODg4W83U6HUwmk1RTO2hqxmvGblVjNptx7do1XLlyBVVVVfXWnDlz5qa9x8fHY/78+Q3bUSKiVqxFn9nk5eVhwoQJ2LRpE1QqVXO302gzZsxASUmJNOXl5TV3S0REzaJFh01mZiYKCgrQq1cv2NrawtbWFvv27cOKFStga2sLnU6HiooKFBcXWyyXn58PvV4PANDr9XWuTqv5+3Y1Go0GarUazs7OaNOmTb01Neuoj52dHTQajcVERHQ/atFhM2jQIJw4cQJZWVnS5O/vj4iICOm/27Zti7S0NGmZnJwcXLx4EYGBgQCAwMBAnDhxwuKqsdTUVGg0Gnh7e0s1tddRU1OzDqVSCT8/P4ua6upqpKWlSTVERHRzLfo7mw4dOqBHjx4W8+zt7eHk5CTNj4qKQmxsLBwdHaHRaDB+/HgEBgaib9++AIDBgwfD29sbI0aMQEJCAkwmE2bPno3o6GjY2dkBAF5//XWsXLkSU6dOxejRo7F79258+umn2Llzp7Td2NhYREZGwt/fH3369MGyZctQVlaGUaNG3aVXg4jo3tWiw6Yhli5dChsbG4SGhqK8vBxGoxGrV6+Wxtu0aYPk5GSMGzcOgYGBsLe3R2RkJBYsWCDVeHh4YOfOnZg0aRKWL1+Ozp0741//+heMRqNUExYWhsLCQsTFxcFkMsHX1xcpKSl1LhogIqK6FEII0dxN3C/MZjO0Wi1KSkpu+/2N35SP7lJXrV/mopFWXyePj3Xw2LRsDTk+DX1fa9Hf2RARUevAsCEiItkxbIiISHYMGyIikh3DhoiIZMewISIi2TFsiIhIdgwbIiKSHcOGiIhkx7AhIiLZMWyIiEh2DBsiIpIdw4aIiGTHsCEiItkxbIiISHYMGyIikh3DhoiIZMewISIi2TFsiIhIdgwbIiKSHcOGiIhkx7AhIiLZMWyIiEh2DBsiIpIdw4aIiGTXosMmPj4evXv3RocOHeDi4oKQkBDk5ORY1Fy/fh3R0dFwcnJC+/btERoaivz8fIuaixcvYujQoWjXrh1cXFwwZcoU3Lhxw6Jm79696NWrF+zs7NC1a1ckJSXV6WfVqlV48MEHoVKpEBAQgMOHD1t9n4mIWqMWHTb79u1DdHQ0fvjhB6SmpqKyshKDBw9GWVmZVDNp0iR8+eWX2Lp1K/bt24dLly7hhRdekMarqqowdOhQVFRU4ODBg9i4cSOSkpIQFxcn1eTm5mLo0KEYOHAgsrKyMHHiRPztb3/Drl27pJotW7YgNjYWc+fOxdGjR9GzZ08YjUYUFBTcnReDiOgephBCiOZuoqEKCwvh4uKCffv2YcCAASgpKUGnTp2wefNmvPjiiwCAM2fOwMvLC+np6ejbty++/vprDBs2DJcuXYJOpwMAJCYmYtq0aSgsLIRSqcS0adOwc+dOnDx5UtpWeHg4iouLkZKSAgAICAhA7969sXLlSgBAdXU13NzcMH78eEyfPr1B/ZvNZmi1WpSUlECj0dyy1m/KR41+fah+mYtGWn2dPD7WwWPTsjXk+DT0fa1Fn9n8WUlJCQDA0dERAJCZmYnKykoEBQVJNZ6enujSpQvS09MBAOnp6fDx8ZGCBgCMRiPMZjNOnTol1dReR01NzToqKiqQmZlpUWNjY4OgoCCppj7l5eUwm80WExHR/eieCZvq6mpMnDgR/fv3R48ePQAAJpMJSqUSDg4OFrU6nQ4mk0mqqR00NeM1Y7eqMZvNuHbtGv7zn/+gqqqq3pqaddQnPj4eWq1Wmtzc3Bq/40RErcA9EzbR0dE4efIkPvnkk+ZupcFmzJiBkpISacrLy2vuloiImoVtczfQEDExMUhOTsb+/fvRuXNnab5er0dFRQWKi4stzm7y8/Oh1+ulmj9fNVZztVrtmj9fwZafnw+NRgO1Wo02bdqgTZs29dbUrKM+dnZ2sLOza/wOExG1Mi36zEYIgZiYGGzbtg27d++Gh4eHxbifnx/atm2LtLQ0aV5OTg4uXryIwMBAAEBgYCBOnDhhcdVYamoqNBoNvL29pZra66ipqVmHUqmEn5+fRU11dTXS0tKkGiIiurkWfWYTHR2NzZs344svvkCHDh2k70e0Wi3UajW0Wi2ioqIQGxsLR0dHaDQajB8/HoGBgejbty8AYPDgwfD29saIESOQkJAAk8mE2bNnIzo6WjrreP3117Fy5UpMnToVo0ePxu7du/Hpp59i586dUi+xsbGIjIyEv78/+vTpg2XLlqGsrAyjRo26+y8MEdE9pkWHzZo1awAATz75pMX8DRs24LXXXgMALF26FDY2NggNDUV5eTmMRiNWr14t1bZp0wbJyckYN24cAgMDYW9vj8jISCxYsECq8fDwwM6dOzFp0iQsX74cnTt3xr/+9S8YjUapJiwsDIWFhYiLi4PJZIKvry9SUlLqXDRARER13VP32dzreJ9N8+C9HC0Xj03Ldt/eZ0NERPcmhg0REcmOYUNERLJj2BARkewYNkREJDuGDRERyY5hQ0REsmPYEBGR7Bg2REQkO4YNERHJjmFDRESyY9gQEZHsGDZERCQ7hg0REcmOYUNERLJj2BARkewYNkREJDuGDRERyY5hQ0REsmPYEBGR7Bg2REQkO4YNERHJjmFDRESyY9gQEZHsGDZERCQ7hg0REcmOYdNIq1atwoMPPgiVSoWAgAAcPny4uVsiImrxGDaNsGXLFsTGxmLu3Lk4evQoevbsCaPRiIKCguZujYioRWPYNML777+PMWPGYNSoUfD29kZiYiLatWuH9evXN3drREQtmm1zN3CvqKioQGZmJmbMmCHNs7GxQVBQENLT0+tdpry8HOXl5dLfJSUlAACz2Xzb7VWVX7vDjqlGQ17vxuLxsQ4em5atIcenpkYIcetCQQ3y66+/CgDi4MGDFvOnTJki+vTpU+8yc+fOFQA4ceLEqdVPeXl5t3wP5ZmNjGbMmIHY2Fjp7+rqahQVFcHJyQkKhaIZO7MOs9kMNzc35OXlQaPRNHc7VAuPTcvV2o6NEAK///47DAbDLesYNg3k7OyMNm3aID8/32J+fn4+9Hp9vcvY2dnBzs7OYp6Dg4NcLTYbjUbTKv5P0xrx2LRcrenYaLXa29bwAoEGUiqV8PPzQ1pamjSvuroaaWlpCAwMbMbOiIhaPp7ZNEJsbCwiIyPh7++PPn36YNmyZSgrK8OoUaOauzUiohaNYdMIYWFhKCwsRFxcHEwmE3x9fZGSkgKdTtfcrTULOzs7zJ07t85HhdT8eGxarvv12CiEuN31akRERHeG39kQEZHsGDZERCQ7hg0REcmOYUN3ZN68efD19W3uNu5pSUlJrfL+q9aAx8Z6GDb3qddeew0KhQIKhQJt27aFTqfD008/jfXr16O6uvqO1hsSEmK9RluQvLw8jB49GgaDAUqlEu7u7pgwYQJ+++23O1pvWFgYzp49a6Uu5VPzvxeFQgFbW1t06dIFsbGxFr//V+PatWtwdHSEs7NzveNr167Fk08+CY1GA4VCgeLi4jvqjcfGOsemqKgI48ePR/fu3aFWq9GlSxe88cYb0u863gmGzX0sODgYly9fxoULF/D1119j4MCBmDBhAoYNG4YbN240d3styr///W/4+/vj3Llz+J//+R+cP38eiYmJ0k29RUVFTV63Wq2Gi4tLk5evqKho8rKNtWHDBly+fBm5ublYvXo1/vu//xsLFy6sU/f555/jkUcegaenJ7Zv315n/OrVqwgODsbMmTPvuCcemz9Y49hcunQJly5dwuLFi3Hy5EkkJSUhJSUFUVFRd96gdX6mku41kZGR4rnnnqszPy0tTQAQ69atE0IIceXKFREVFSWcnZ1Fhw4dxMCBA0VWVpZUP3fuXNGzZ0/pv/GnH+fbs2ePEEKIqVOnim7dugm1Wi08PDzE7NmzRUVFhdy7aTXBwcGic+fO4urVqxbzL1++LNq1aydef/11IYQQ7u7u4q233hIjRowQ9vb2okuXLuKLL74QBQUF4q9//auwt7cXPj4+IiMjQ1rHhg0bhFartVjvjh07hL+/v7CzsxNOTk4iJCREGnN3dxcLFiwQI0aMEB06dBCRkZFCCCE+++wz4e3tLZRKpXB3dxeLFy+2WKe7u7t4++23xahRo0T79u2Fm5ub+OCDDxr8GgAQ27Zts5gXFRUlhgwZUqf2ySefFImJiWLNmjXi6aefvuk69+zZIwCIK1euNLiPP+OxkefY1Pj000+FUqkUlZWVDe6n3h7vaGm6Z90sbIQQomfPnuKZZ54RQggRFBQknn32WZGRkSHOnj0rJk+eLJycnMRvv/0mhLAMm99//128/PLLIjg4WFy+fFlcvnxZlJeXCyGEeOutt8SBAwdEbm6u2LFjh9DpdOK9996TfT+t4bfffhMKhUK888479Y6PGTNGdOzYUVRXVwt3d3fh6OgoEhMTxdmzZ8W4ceOERqMRwcHB4tNPPxU5OTkiJCREeHl5ierqaiFE3Te05ORk0aZNGxEXFydOnz4tsrKyLLbt7u4uNBqNWLx4sTh//rw4f/68OHLkiLCxsRELFiwQOTk5YsOGDUKtVosNGzZYLOfo6ChWrVolzp07J+Lj44WNjY04c+ZMg16HP7+h5eTkCA8PDzF//nyLuvPnzws7OztRVFQkfvvtN6FSqcSFCxfqXeedhg2PzR/kODY11q1bJ5ydnRvUxy17vOM10D3pVmETFhYmvLy8xHfffSc0Go24fv26xfhDDz0k/aurdtjcbr21LVq0SPj5+TW1/bvqhx9+qPdfjjXef/99AUDk5+cLd3d38eqrr0pjly9fFgDEnDlzpHnp6ekCgLh8+bIQou4bWmBgoIiIiLhpP+7u7hb/mhZCiFdeeaXOv1KnTJkivL29LZar3Vt1dbVwcXERa9asufnO1wJAqFQqYW9vL+zs7AQAMWzYsDpnqDNnzrTo77nnnhNz586td513GjY8Nn+Q49gIIURhYaHo0qWLmDlzZoP6uBV+Z0N1CCGgUCjw448/orS0FE5OTmjfvr005ebm4qeffmrUOrds2YL+/ftDr9ejffv2mD17Ni5evCjTHshDNPDHNh599FHpv2t+ysjHx6fOvJs9TjwrKwuDBg265Tb8/f0t/s7Ozkb//v0t5vXv3x/nzp1DVVVVvb0pFAro9fpGPdZ86dKlyMrKwo8//ojk5GScPXsWI0aMkMarqqqwceNGvPrqq9K8V199FUlJSXd04cnt8NhY/9iYzWYMHToU3t7emDdvXoP7uBn+NhrVkZ2dDQ8PD5SWlsLV1RV79+6tU9OYy0HT09MRERGB+fPnw2g0QqvV4pNPPsGSJUus17SMunbtCoVCgezsbDz//PN1xrOzs9GxY0d06tQJANC2bVtprOa5RfXNu9mbr1qtvm1P9vb2Dd+BWmr3UdNLY0JAr9eja9euAIDu3bvj999/x/Dhw7Fw4UJ07doVu3btwq+//oqwsDCL5aqqqpCWloann366SX3fDI/N/7Pmsfn9998RHByMDh06YNu2bXV6awqe2ZCF3bt348SJEwgNDUWvXr1gMplga2uLrl27WkzOzs71Lq9UKi3+tQYABw8ehLu7O2bNmgV/f39069YNP//8893YHatwcnLC008/jdWrV+PaNctHDptMJmzatAlhYWFWeyDeo48+avEoi4bw8vLCgQMHLOYdOHAADz/8MNq0aWOVvupTs+6a1+XDDz9EeHg4srKyLKbw8HB8+OGHVt8+j83NNfXYmM1mDB48GEqlEjt27IBKpbJKPzyzuY+Vl5fDZDKhqqoK+fn5SElJQXx8PIYNG4aRI0fCxsYGgYGBCAkJQUJCAh5++GFcunQJO3fuxPPPP1/n4wIAePDBB7Fr1y7k5OTAyckJWq0W3bp1w8WLF/HJJ5+gd+/e2LlzJ7Zt29YMe9x0K1euRL9+/WA0GrFw4UJ4eHjg1KlTmDJlCh544AG8/fbbVtvW3LlzMWjQIDz00EMIDw/HjRs38NVXX2HatGk3XWby5Mno3bs33nrrLYSFhSE9PR0rV67E6tWrrdYXABQXF8NkMqG6uhrnzp3DggUL8PDDD8PLywuFhYX48ssvsWPHDvTo0cNiuZEjR+L5559HUVERHB0dYTKZYDKZcP78eQDAiRMn0KFDB3Tp0gWOjo6N6onH5g/WODa2trYYPHgwrl69io8//hhmsxlmsxkA0KlTpzsLxzv+1ofuSZGRkdLlyba2tqJTp04iKChIrF+/XlRVVUl1ZrNZjB8/XhgMBtG2bVvh5uYmIiIixMWLF4UQdS8QKCgoEE8//bRo3769xaXPU6ZMEU5OTqJ9+/YiLCxMLF26tM4lpS3dhQsXRGRkpNDpdNJrMX78ePGf//xHqnF3dxdLly61WA5/+gI7NzdXABDHjh0TQtR/ee3nn38ufH19hVKpFM7OzuKFF1645TaE+P/La9u2bSu6dOkiFi1aZDFe33I9e/a85RfEf96PmkmhUAhXV1cRFhYmfvrpJyGEEIsXLxYODg71XtJeXl4uHBwcxPLly4UQ9V8mD8DiCq3G4LGxzrGpuWCjvik3N7dBvdwMHzFARESy43c2REQkO4YNEeGdd96xuLy99vTMM880d3v3tdZybPgxGhGhqKjopr8hplar8cADD9zljqhGazk2DBsiIpIdP0YjIiLZMWyIiEh2DBsiIpIdw4aoFXrwwQexbNky6W+FQlHvQ8xqa81PWaXmx5+rIboPXL58GR07dgQAXLhwAR4eHjh27Bh8fX2lmuXLlzf415OJGothQ3Qf0Ov1t63RarV3oRO6X/FjNCKZVVdXIyEhAV27doWdnR26dOki/TjkiRMn8NRTT0GtVsPJyQljx45FaWmptGzNR1uLFy+Gq6srnJycEB0djcrKSqmmoKAAzz77LNRqNTw8PLBp06Y6PdT+GM3DwwMA8Nhjj0GhUODJJ5+02FaN8vJyvPHGG3BxcYFKpcLjjz+OjIwMaXzv3r1QKBRIS0uDv78/2rVrh379+iEnJ8daLx21IgwbIpnNmDED7777LubMmYPTp09j8+bN0Ol0KCsrg9FoRMeOHZGRkYGtW7fi22+/RUxMjMXye/bswU8//YQ9e/Zg48aNSEpKQlJSkjT+2muvIS8vD3v27MFnn32G1atX3/KhW4cPHwYAfPvtt7h8+TL+93//t966qVOn4vPPP8fGjRtx9OhRdO3aFUajsc4NhrNmzcKSJUtw5MgR2NraYvTo0U18pahVu6Of8SSiWzKbzcLOzk6sW7euztjatWtFx44dRWlpqTRv586dwsbGRphMJiHEH7/O7e7uLm7cuCHVvPTSSyIsLEwI8cez5gGIw4cPS+PZ2dkCgMWvCKPWrxv/+ZeNa9R+pHdpaalo27at2LRpkzReUVEhDAaDSEhIEEL8/yOdv/32W4v+AYhr16414lWi+wHPbIhklJ2djfLy8nofJZydnY2ePXtaPNmxf//+qK6utvgo6pFHHrF4joirq6t05pKdnQ1bW1v4+flJ456eno16kmp9fvrpJ1RWVlo8zrht27bo06cPsrOzLWprP87Y1dUVwM0fq0z3L4YNkYwa8hjh27nTxwXLrTGPVab7F8OGSEbdunWDWq2u91HCXl5e+PHHH1FWVibNO3DgAGxsbNC9e/cGrd/T0xM3btxAZmamNC8nJwfFxcU3XUapVAJAncd31/bQQw9BqVRaPM64srISGRkZ8Pb2blBvRLXx0mciGalUKkybNg1Tp06FUqlE//79UVhYiFOnTiEiIgJz585FZGQk5s2bh8LCQowfPx4jRoyATqdr0Pq7d++O4OBg/P3vf8eaNWtga2uLiRMn3vKMysXFBWq1GikpKejcuTNUKlWdy57t7e0xbtw4TJkyBY6OjujSpQsSEhJw9epVREVF3dFrQvcnntkQyWzOnDmYPHky4uLi4OXlhbCwMBQUFKBdu3bYtWsXioqK0Lt3b7z44osYNGgQVq5c2aj1b9iwAQaDAX/5y1/wwgsvYOzYsXBxcblpva2tLVasWIEPPvgABoMBzz33XL117777LkJDQzFixAj06tUL58+fx65du6SbQ4kag48YICIi2fHMhoiIZMewISIi2TFsiIhIdgwbIiKSHcOGiIhkx7AhIiLZMWyIiEh2DBsiIpIdw4aIiGTHsCEiItkxbIiISHYMGyIikt3/AVS63vyZjaxfAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -1248,7 +1281,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -1389,7 +1422,7 @@ " 1\n", " 1\n", " 2\n", - " -4.452255\n", + " -3.500000\n", " 1.0\n", " \n", " \n", @@ -1430,11 +1463,11 @@ "5 19832 0.000000 1.0 \n", "6 2 -1.731675 1.0 \n", "7 2 -1.462176 1.0 \n", - "9 2 -4.452255 1.0 \n", + "9 2 -3.500000 1.0 \n", "10 2 -1.553395 1.0 " ] }, - "execution_count": 14, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -1453,7 +1486,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -1490,63 +1523,63 @@ " \n", " \n", " \n", - " 0\n", - " 5027212\n", - " 4967837\n", + " 1\n", + " 5955236\n", + " 3000775\n", " \n", " Delta\n", - " 1\n", + " 2\n", " 0\n", - " 10176\n", + " 8516\n", " 0.000000\n", " 1.0\n", " \n", " \n", - " 2\n", - " 13479201\n", - " 16707349\n", + " 3\n", + " 15250884\n", + " 19953602\n", " \n", " Omicron_BA1\n", - " 1\n", + " 2\n", " 0\n", - " 24216\n", + " 22495\n", " 0.000000\n", " 1.0\n", " \n", " \n", - " 4\n", - " 15195250\n", - " 12396402\n", + " 5\n", + " 18959708\n", + " 24113895\n", " \n", " Omicron_BA2\n", - " 1\n", + " 2\n", " 0\n", - " 21020\n", + " 19832\n", " 0.000000\n", " 1.0\n", " \n", " \n", - " 6\n", - " 978\n", - " 291\n", + " 7\n", + " 853\n", + " 156\n", " A1015D\n", " Delta\n", - " 1\n", + " 2\n", " 1\n", " 2\n", - " -1.731675\n", + " -1.462176\n", " 1.0\n", " \n", " \n", - " 9\n", - " 644\n", - " 24\n", - " A1015D\n", - " Omicron_BA2\n", - " 1\n", - " 1\n", + " 14\n", + " 3757\n", + " 2030\n", + " A1015S\n", + " Delta\n", " 2\n", - " -4.452255\n", + " 1\n", + " 6\n", + " 0.100722\n", " 1.0\n", " \n", " \n", @@ -1562,107 +1595,120 @@ " ...\n", " \n", " \n", - " 335503\n", - " 627\n", - " 13\n", - " Y91T N137T F375T F562L Q804H\n", - " Omicron_BA2\n", - " 1\n", - " 5\n", + " 335513\n", + " 633\n", + " 8\n", + " Y91V E132Q Q675L A845E G1167D\n", + " Omicron_BA1\n", " 2\n", - " -5.298183\n", - " 1.0\n", - " \n", - " \n", - " 335506\n", - " 962\n", - " 63\n", - " Y91T S98T A845S L1193P\n", - " Omicron_BA2\n", + " 5\n", " 1\n", - " 4\n", - " 2\n", - " -3.638914\n", + " -3.500000\n", " 1.0\n", " \n", " \n", - " 335507\n", - " 315\n", - " 45\n", - " Y91T T315I K378M\n", + " 335514\n", + " 497\n", + " 7\n", + " Y91V H505N I1216T\n", " Omicron_BA1\n", - " 1\n", + " 2\n", " 3\n", " 1\n", - " -3.117103\n", + " -3.500000\n", " 1.0\n", " \n", " \n", - " 335509\n", - " 229\n", - " 1\n", - " Y91T T874I\n", - " Omicron_BA1\n", - " 1\n", + " 335517\n", + " 310\n", + " 26\n", + " Y91V S112N M177K L335P N405A C671R K679R T859A...\n", + " Omicron_BA2\n", " 2\n", - " 1\n", - " -8.148952\n", + " 9\n", + " 2\n", + " -3.500000\n", " 1.0\n", " \n", " \n", - " 335510\n", - " 780\n", - " 11\n", - " Y91V\n", - " Omicron_BA1\n", - " 1\n", - " 1\n", - " 3\n", - " -6.457647\n", + " 335519\n", + " 499\n", + " 71\n", + " Y91V S98Y D138* Y144V N280D N405P P463S S982R ...\n", + " Omicron_BA2\n", + " 2\n", + " 9\n", + " 2\n", + " -3.160077\n", + " 1.0\n", + " \n", + " \n", + " 335521\n", + " 888\n", + " 71\n", + " Y91V T883I\n", + " Omicron_BA2\n", + " 2\n", + " 2\n", + " 2\n", + " -3.500000\n", " 1.0\n", " \n", " \n", "\n", - "

153084 rows × 9 columns

\n", + "

142673 rows × 9 columns

\n", "" ], "text/plain": [ - " pre_count post_count aa_substitutions condition \\\n", - "0 5027212 4967837 Delta \n", - "2 13479201 16707349 Omicron_BA1 \n", - "4 15195250 12396402 Omicron_BA2 \n", - "6 978 291 A1015D Delta \n", - "9 644 24 A1015D Omicron_BA2 \n", - "... ... ... ... ... \n", - "335503 627 13 Y91T N137T F375T F562L Q804H Omicron_BA2 \n", - "335506 962 63 Y91T S98T A845S L1193P Omicron_BA2 \n", - "335507 315 45 Y91T T315I K378M Omicron_BA1 \n", - "335509 229 1 Y91T T874I Omicron_BA1 \n", - "335510 780 11 Y91V Omicron_BA1 \n", + " pre_count post_count \\\n", + "1 5955236 3000775 \n", + "3 15250884 19953602 \n", + "5 18959708 24113895 \n", + "7 853 156 \n", + "14 3757 2030 \n", + "... ... ... \n", + "335513 633 8 \n", + "335514 497 7 \n", + "335517 310 26 \n", + "335519 499 71 \n", + "335521 888 71 \n", + "\n", + " aa_substitutions condition \\\n", + "1 Delta \n", + "3 Omicron_BA1 \n", + "5 Omicron_BA2 \n", + "7 A1015D Delta \n", + "14 A1015S Delta \n", + "... ... ... \n", + "335513 Y91V E132Q Q675L A845E G1167D Omicron_BA1 \n", + "335514 Y91V H505N I1216T Omicron_BA1 \n", + "335517 Y91V S112N M177K L335P N405A C671R K679R T859A... Omicron_BA2 \n", + "335519 Y91V S98Y D138* Y144V N280D N405P P463S S982R ... Omicron_BA2 \n", + "335521 Y91V T883I Omicron_BA2 \n", "\n", " replicate n_subs barcodes func_score weight \n", - "0 1 0 10176 0.000000 1.0 \n", - "2 1 0 24216 0.000000 1.0 \n", - "4 1 0 21020 0.000000 1.0 \n", - "6 1 1 2 -1.731675 1.0 \n", - "9 1 1 2 -4.452255 1.0 \n", + "1 2 0 8516 0.000000 1.0 \n", + "3 2 0 22495 0.000000 1.0 \n", + "5 2 0 19832 0.000000 1.0 \n", + "7 2 1 2 -1.462176 1.0 \n", + "14 2 1 6 0.100722 1.0 \n", "... ... ... ... ... ... \n", - "335503 1 5 2 -5.298183 1.0 \n", - "335506 1 4 2 -3.638914 1.0 \n", - "335507 1 3 1 -3.117103 1.0 \n", - "335509 1 2 1 -8.148952 1.0 \n", - "335510 1 1 3 -6.457647 1.0 \n", + "335513 2 5 1 -3.500000 1.0 \n", + "335514 2 3 1 -3.500000 1.0 \n", + "335517 2 9 2 -3.500000 1.0 \n", + "335519 2 9 2 -3.160077 1.0 \n", + "335521 2 2 2 -3.500000 1.0 \n", "\n", - "[153084 rows x 9 columns]" + "[142673 rows x 9 columns]" ] }, - "execution_count": 15, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "func_scores_collapsed_df.query(\"replicate == 1\", inplace=True)\n", + "func_scores_collapsed_df.query(\"replicate == 2\", inplace=True)\n", "func_scores_collapsed_df" ] }, @@ -1675,20 +1721,20 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/Users/wsdewitt/miniconda3/envs/multidms/lib/python3.12/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n", + "/home/jgallowa/mambaforge/envs/multidms-dev/lib/python3.11/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n", " self.pid = os.fork()\n", - "/Users/wsdewitt/miniconda3/envs/multidms/lib/python3.12/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n", + "/home/jgallowa/mambaforge/envs/multidms-dev/lib/python3.11/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n", " self.pid = os.fork()\n", - "/Users/wsdewitt/miniconda3/envs/multidms/lib/python3.12/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n", + "/home/jgallowa/mambaforge/envs/multidms-dev/lib/python3.11/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n", " self.pid = os.fork()\n", - "/Users/wsdewitt/miniconda3/envs/multidms/lib/python3.12/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n", + "/home/jgallowa/mambaforge/envs/multidms-dev/lib/python3.11/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n", " self.pid = os.fork()\n" ] }, @@ -1698,7 +1744,7 @@ "Data(rep-1)" ] }, - "execution_count": 16, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -1721,27 +1767,27 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'X': {'Delta': BCOO(int8[27449, 10615], nse=891669),\n", - " 'Omicron_BA1': BCOO(int8[59382, 10615], nse=154708),\n", - " 'Omicron_BA2': BCOO(int8[53704, 10615], nse=895779)},\n", - " 'y': {'Delta': Array([ 0. , -1.73167462, -1.55339474, ..., -1.94029885,\n", - " -4.10472485, -2.67718849], dtype=float64),\n", - " 'Omicron_BA1': Array([ 0. , -3.4956144 , -0.46983596, ..., -3.11710278,\n", - " -8.14895164, -6.45764655], dtype=float64),\n", - " 'Omicron_BA2': Array([ 0. , -4.45225541, -0.42229756, ..., -2.01372956,\n", - " -5.29818295, -3.63891419], dtype=float64)},\n", + "{'X': {'Delta': BCOO(int8[26743, 10722], nse=869823),\n", + " 'Omicron_BA1': BCOO(int8[53209, 10722], nse=137253),\n", + " 'Omicron_BA2': BCOO(int8[51122, 10722], nse=853243)},\n", + " 'y': {'Delta': Array([ 0. , -1.46217618, 0.10072214, ..., -0.95950872,\n", + " -3.0166309 , -3.39281081], dtype=float64),\n", + " 'Omicron_BA1': Array([ 0. , -0.1441993 , 0.15470144, ..., -3.5 ,\n", + " -3.5 , -3.5 ], dtype=float64),\n", + " 'Omicron_BA2': Array([ 0. , -0.04110356, -0.62651354, ..., -3.3366282 ,\n", + " -3.5 , -3.5 ], dtype=float64)},\n", " 'w': {'Delta': Array([1., 1., 1., ..., 1., 1., 1.], dtype=float64),\n", " 'Omicron_BA1': Array([1., 1., 1., ..., 1., 1., 1.], dtype=float64),\n", " 'Omicron_BA2': Array([1., 1., 1., ..., 1., 1., 1.], dtype=float64)}}" ] }, - "execution_count": 17, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -1759,12 +1805,12 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1798,7 +1844,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -1807,7 +1853,7 @@ "('Omicron_BA1', 1)" ] }, - "execution_count": 19, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -1843,7 +1889,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -1867,7 +1913,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -1893,7 +1939,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -1923,14 +1969,20 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Delta\n", + "Delta\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Omicron_BA1\n", "Omicron_BA2\n" ] @@ -1938,21 +1990,21 @@ { "data": { "text/plain": [ - "{'X': {'Delta': BCOO(int8[27449, 10615], nse=78891),\n", - " 'Omicron_BA1': BCOO(int8[59382, 10615], nse=154708),\n", - " 'Omicron_BA2': BCOO(int8[53704, 10615], nse=165797)},\n", - " 'y': {'Delta': Array([ 0. , -1.73167462, -1.55339474, ..., -1.94029885,\n", - " -4.10472485, -2.67718849], dtype=float64),\n", - " 'Omicron_BA1': Array([ 0. , -3.4956144 , -0.46983596, ..., -3.11710278,\n", - " -8.14895164, -6.45764655], dtype=float64),\n", - " 'Omicron_BA2': Array([ 0. , -4.45225541, -0.42229756, ..., -2.01372956,\n", - " -5.29818295, -3.63891419], dtype=float64)},\n", + "{'X': {'Delta': BCOO(int8[26743, 10722], nse=78045),\n", + " 'Omicron_BA1': BCOO(int8[53209, 10722], nse=137253),\n", + " 'Omicron_BA2': BCOO(int8[51122, 10722], nse=158121)},\n", + " 'y': {'Delta': Array([ 0. , -1.46217618, 0.10072214, ..., -0.95950872,\n", + " -3.0166309 , -3.39281081], dtype=float64),\n", + " 'Omicron_BA1': Array([ 0. , -0.1441993 , 0.15470144, ..., -3.5 ,\n", + " -3.5 , -3.5 ], dtype=float64),\n", + " 'Omicron_BA2': Array([ 0. , -0.04110356, -0.62651354, ..., -3.3366282 ,\n", + " -3.5 , -3.5 ], dtype=float64)},\n", " 'w': {'Delta': Array([1., 1., 1., ..., 1., 1., 1.], dtype=float64),\n", " 'Omicron_BA1': Array([1., 1., 1., ..., 1., 1., 1.], dtype=float64),\n", " 'Omicron_BA2': Array([1., 1., 1., ..., 1., 1., 1.], dtype=float64)}}" ] }, - "execution_count": 23, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -2000,12 +2052,12 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2055,7 +2107,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ @@ -2175,7 +2227,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -2186,7 +2238,7 @@ " [ 0., -1., 1.]], dtype=float64)" ] }, - "execution_count": 26, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -2207,7 +2259,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -2218,7 +2270,7 @@ " [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1]], dtype=int64, weak_type=True)" ] }, - "execution_count": 27, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -2231,16 +2283,16 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "3.0000000000000013" + "3.0000000000000036" ] }, - "execution_count": 28, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } @@ -2261,7 +2313,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ @@ -2302,7 +2354,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ @@ -2315,7 +2367,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -2332,7 +2384,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -2341,18 +2393,18 @@ "{'Δ': Array([[0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.]], dtype=float64),\n", - " 'β': {'Delta': Array([1.42313303e-05, 2.13469954e-05, 2.13469954e-05, ...,\n", - " 2.18575458e-05, 5.32736123e-05, 1.26156672e-05], dtype=float64),\n", - " 'Omicron_BA1': Array([ 0.00000000e+00, 2.13469954e-05, 0.00000000e+00, ...,\n", - " -3.79166571e-06, 1.33131281e-04, 1.12488034e-06], dtype=float64),\n", - " 'Omicron_BA2': Array([0.00000000e+00, 3.55783257e-05, 0.00000000e+00, ...,\n", - " 2.35790239e-04, 1.40944253e-04, 0.00000000e+00], dtype=float64)},\n", - " 'β0': {'Delta': Array(0.07840502, dtype=float64, weak_type=True),\n", - " 'Omicron_BA1': Array(0.21032275, dtype=float64, weak_type=True),\n", - " 'Omicron_BA2': Array(0.23074362, dtype=float64, weak_type=True)}}" + " 'β': {'Delta': Array([1.47372575e-05, 7.62927812e-05, 3.81463906e-05, ...,\n", + " 5.22781722e-05, 1.85914083e-05, 1.57605936e-05], dtype=float64),\n", + " 'Omicron_BA1': Array([ 0.00000000e+00, 3.05171125e-05, 0.00000000e+00, ...,\n", + " -2.77650030e-05, 1.38535009e-04, 0.00000000e+00], dtype=float64),\n", + " 'Omicron_BA2': Array([0.00000000e+00, 6.10342249e-05, 0.00000000e+00, ...,\n", + " 2.96050491e-04, 1.45183224e-04, 0.00000000e+00], dtype=float64)},\n", + " 'β0': {'Delta': Array(0.0956391, dtype=float64, weak_type=True),\n", + " 'Omicron_BA1': Array(0.22288956, dtype=float64, weak_type=True),\n", + " 'Omicron_BA2': Array(0.25063313, dtype=float64, weak_type=True)}}" ] }, - "execution_count": 32, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -2363,7 +2415,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 34, "metadata": {}, "outputs": [ { @@ -2380,7 +2432,7 @@ " 'Omicron_BA2': Array(0., dtype=float64)}}" ] }, - "execution_count": 33, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } @@ -2391,16 +2443,16 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Array(1.24439625, dtype=float64)" + "Array(1.17131091, dtype=float64)" ] }, - "execution_count": 34, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } @@ -2411,7 +2463,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 36, "metadata": {}, "outputs": [], "source": [ @@ -2431,11 +2483,11 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ - "l1reg = 4e-5\n", + "l1reg = 0.0\n", "admm_niter = 50\n", "admm_τ = 1.0\n", "admm_μ = 0.99 * admm_τ / eig\n", @@ -2447,216 +2499,9 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 38, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Iteration 10, objective=1.06e+00, stepsize=1.60e+01, error=2.41e-02, shift sparsity = [0.81 1.00 0.82], duality gap = 1.13e-12\n", - "Iteration 20, objective=1.03e+00, stepsize=3.20e+01, error=1.99e-02, shift sparsity = [0.82 1.00 0.83], duality gap = 2.25e-12\n", - "Iteration 30, objective=9.86e-01, stepsize=1.60e+01, error=3.95e-02, shift sparsity = [0.82 1.00 0.84], duality gap = 1.15e-12\n", - "Iteration 40, objective=9.46e-01, stepsize=8.00e+00, error=9.34e-02, shift sparsity = [0.83 1.00 0.84], duality gap = 6.02e-13\n", - "Iteration 50, objective=9.02e-01, stepsize=6.40e+01, error=1.67e-02, shift sparsity = [0.84 1.00 0.85], duality gap = 4.67e-12\n", - "Iteration 60, objective=8.58e-01, stepsize=1.60e+01, error=6.45e-02, shift sparsity = [0.84 1.00 0.85], duality gap = 1.18e-12\n", - "Iteration 70, objective=8.23e-01, stepsize=8.00e+00, error=1.12e-01, shift sparsity = [0.84 1.00 0.85], duality gap = 6.43e-13\n", - "Iteration 80, objective=7.96e-01, stepsize=1.60e+01, error=5.06e-02, shift sparsity = [0.85 1.00 0.85], duality gap = 1.21e-12\n", - "Iteration 90, objective=7.74e-01, stepsize=1.60e+01, error=4.68e-02, shift sparsity = [0.85 1.00 0.85], duality gap = 1.25e-12\n", - "Iteration 100, objective=7.55e-01, stepsize=8.00e+00, error=8.81e-02, shift sparsity = [0.86 1.00 0.86], duality gap = 6.94e-13\n", - "Iteration 110, objective=7.38e-01, stepsize=8.00e+00, error=8.46e-02, shift sparsity = [0.86 1.00 0.86], duality gap = 7.36e-13\n", - "Iteration 120, objective=7.23e-01, stepsize=1.60e+01, error=4.11e-02, shift sparsity = [0.87 1.00 0.87], duality gap = 1.27e-12\n", - "Iteration 130, objective=7.09e-01, stepsize=8.00e+00, error=8.25e-02, shift sparsity = [0.87 1.00 0.87], duality gap = 1.13e-12\n", - "Iteration 140, objective=6.96e-01, stepsize=1.60e+01, error=4.14e-02, shift sparsity = [0.88 1.00 0.87], duality gap = 1.42e-12\n", - "Iteration 150, objective=6.83e-01, stepsize=8.00e+00, error=8.45e-02, shift sparsity = [0.88 1.00 0.88], duality gap = 6.40e-13\n", - "Iteration 160, objective=6.72e-01, stepsize=8.00e+00, error=8.37e-02, shift sparsity = [0.89 1.00 0.88], duality gap = 6.51e-13\n", - "Iteration 170, objective=6.62e-01, stepsize=8.00e+00, error=8.14e-02, shift sparsity = [0.89 1.00 0.88], duality gap = 6.98e-13\n", - "Iteration 180, objective=6.52e-01, stepsize=8.00e+00, error=7.93e-02, shift sparsity = [0.89 1.00 0.89], duality gap = 6.67e-13\n", - "Iteration 190, objective=6.44e-01, stepsize=8.00e+00, error=7.74e-02, shift sparsity = [0.90 1.00 0.89], duality gap = 6.38e-13\n", - "Iteration 200, objective=6.37e-01, stepsize=1.60e+01, error=3.79e-02, shift sparsity = [0.90 1.00 0.89], duality gap = 1.18e-12\n", - "Iteration 210, objective=6.30e-01, stepsize=8.00e+00, error=7.42e-02, shift sparsity = [0.90 1.00 0.89], duality gap = 1.14e-12\n", - "Iteration 220, objective=6.23e-01, stepsize=8.00e+00, error=7.20e-02, shift sparsity = [0.91 1.00 0.90], duality gap = 6.33e-13\n", - "Iteration 230, objective=6.18e-01, stepsize=8.00e+00, error=7.06e-02, shift sparsity = [0.91 1.00 0.90], duality gap = 6.25e-13\n", - "Iteration 240, objective=6.13e-01, stepsize=8.00e+00, error=6.86e-02, shift sparsity = [0.91 1.00 0.90], duality gap = 6.28e-13\n", - "Iteration 250, objective=6.08e-01, stepsize=8.00e+00, error=6.68e-02, shift sparsity = [0.92 1.00 0.90], duality gap = 6.30e-13\n", - "Iteration 260, objective=6.04e-01, stepsize=1.60e+01, error=3.29e-02, shift sparsity = [0.92 1.00 0.90], duality gap = 1.16e-12\n", - "Iteration 270, objective=6.00e-01, stepsize=1.60e+01, error=3.20e-02, shift sparsity = [0.92 1.00 0.90], duality gap = 1.16e-12\n", - "Iteration 280, objective=5.96e-01, stepsize=8.00e+00, error=6.24e-02, shift sparsity = [0.92 1.00 0.91], duality gap = 6.47e-13\n", - "Iteration 290, objective=5.93e-01, stepsize=8.00e+00, error=6.06e-02, shift sparsity = [0.92 1.00 0.91], duality gap = 6.34e-13\n", - "Iteration 300, objective=5.90e-01, stepsize=8.00e+00, error=5.91e-02, shift sparsity = [0.92 1.00 0.91], duality gap = 6.31e-13\n", - "Iteration 310, objective=5.87e-01, stepsize=8.00e+00, error=5.79e-02, shift sparsity = [0.93 1.00 0.91], duality gap = 6.31e-13\n", - "Iteration 320, objective=5.84e-01, stepsize=8.00e+00, error=5.66e-02, shift sparsity = [0.93 1.00 0.91], duality gap = 6.31e-13\n", - "Iteration 330, objective=5.82e-01, stepsize=8.00e+00, error=5.51e-02, shift sparsity = [0.93 1.00 0.91], duality gap = 6.46e-13\n", - "Iteration 340, objective=5.79e-01, stepsize=8.00e+00, error=5.39e-02, shift sparsity = [0.93 1.00 0.91], duality gap = 6.30e-13\n", - "Iteration 350, objective=5.77e-01, stepsize=8.00e+00, error=5.27e-02, shift sparsity = [0.93 1.00 0.91], duality gap = 6.32e-13\n", - "Iteration 360, objective=5.75e-01, stepsize=1.60e+01, error=2.58e-02, shift sparsity = [0.93 1.00 0.91], duality gap = 1.15e-12\n", - "Iteration 370, objective=5.74e-01, stepsize=1.60e+01, error=2.52e-02, shift sparsity = [0.93 1.00 0.92], duality gap = 1.14e-12\n", - "Iteration 380, objective=5.72e-01, stepsize=1.60e+01, error=2.48e-02, shift sparsity = [0.94 1.00 0.92], duality gap = 1.15e-12\n", - "Iteration 390, objective=5.70e-01, stepsize=8.00e+00, error=4.84e-02, shift sparsity = [0.94 1.00 0.92], duality gap = 6.38e-13\n", - "Iteration 400, objective=5.69e-01, stepsize=8.00e+00, error=4.75e-02, shift sparsity = [0.94 1.00 0.92], duality gap = 6.41e-13\n", - "Iteration 410, objective=5.67e-01, stepsize=8.00e+00, error=4.67e-02, shift sparsity = [0.94 1.00 0.92], duality gap = 6.36e-13\n", - "Iteration 420, objective=5.66e-01, stepsize=1.60e+01, error=2.29e-02, shift sparsity = [0.94 1.00 0.92], duality gap = 1.14e-12\n", - "Iteration 430, objective=5.65e-01, stepsize=1.60e+01, error=2.25e-02, shift sparsity = [0.94 1.00 0.92], duality gap = 1.15e-12\n", - "Iteration 440, objective=5.64e-01, stepsize=8.00e+00, error=4.41e-02, shift sparsity = [0.94 1.00 0.92], duality gap = 6.29e-13\n", - "Iteration 450, objective=5.63e-01, stepsize=8.00e+00, error=4.35e-02, shift sparsity = [0.94 1.00 0.92], duality gap = 6.24e-13\n", - "Iteration 460, objective=5.61e-01, stepsize=1.60e+01, error=2.14e-02, shift sparsity = [0.94 1.00 0.92], duality gap = 1.16e-12\n", - "Iteration 470, objective=5.60e-01, stepsize=1.60e+01, error=2.10e-02, shift sparsity = [0.94 1.00 0.92], duality gap = 1.16e-12\n", - "Iteration 480, objective=5.59e-01, stepsize=8.00e+00, error=4.13e-02, shift sparsity = [0.94 1.00 0.92], duality gap = 6.54e-13\n", - "Iteration 490, objective=5.59e-01, stepsize=8.00e+00, error=4.07e-02, shift sparsity = [0.94 1.00 0.92], duality gap = 6.43e-13\n", - "Iteration 500, objective=5.58e-01, stepsize=1.60e+01, error=2.01e-02, shift sparsity = [0.94 1.00 0.93], duality gap = 1.15e-12\n", - "Iteration 510, objective=5.57e-01, stepsize=1.60e+01, error=1.98e-02, shift sparsity = [0.94 1.00 0.92], duality gap = 1.14e-12\n", - "Iteration 520, objective=5.56e-01, stepsize=8.00e+00, error=3.90e-02, shift sparsity = [0.94 1.00 0.93], duality gap = 6.45e-13\n", - "Iteration 530, objective=5.55e-01, stepsize=8.00e+00, error=3.85e-02, shift sparsity = [0.94 1.00 0.93], duality gap = 6.45e-13\n", - "Iteration 540, objective=5.55e-01, stepsize=1.60e+01, error=1.90e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.14e-12\n", - "Iteration 550, objective=5.54e-01, stepsize=8.00e+00, error=3.75e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.47e-13\n", - "Iteration 560, objective=5.53e-01, stepsize=8.00e+00, error=3.70e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.45e-13\n", - "Iteration 570, objective=5.53e-01, stepsize=1.60e+01, error=1.83e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.13e-12\n", - "Iteration 580, objective=5.52e-01, stepsize=8.00e+00, error=3.61e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.43e-13\n", - "Iteration 590, objective=5.51e-01, stepsize=8.00e+00, error=3.57e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.43e-13\n", - "Iteration 600, objective=5.51e-01, stepsize=1.60e+01, error=1.77e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.13e-12\n", - "Iteration 610, objective=5.50e-01, stepsize=8.00e+00, error=3.49e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.40e-13\n", - "Iteration 620, objective=5.50e-01, stepsize=8.00e+00, error=3.46e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.38e-13\n", - "Iteration 630, objective=5.49e-01, stepsize=1.60e+01, error=1.71e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.12e-12\n", - "Iteration 640, objective=5.49e-01, stepsize=8.00e+00, error=3.38e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.41e-13\n", - "Iteration 650, objective=5.48e-01, stepsize=8.00e+00, error=3.35e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.42e-13\n", - "Iteration 660, objective=5.48e-01, stepsize=1.60e+01, error=1.66e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.12e-12\n", - "Iteration 670, objective=5.47e-01, stepsize=8.00e+00, error=3.29e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.52e-13\n", - "Iteration 680, objective=5.47e-01, stepsize=1.60e+01, error=1.63e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.13e-12\n", - "Iteration 690, objective=5.46e-01, stepsize=1.60e+01, error=1.61e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.13e-12\n", - "Iteration 700, objective=5.46e-01, stepsize=8.00e+00, error=3.19e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.61e-13\n", - "Iteration 710, objective=5.46e-01, stepsize=1.60e+01, error=1.58e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.12e-12\n", - "Iteration 720, objective=5.45e-01, stepsize=8.00e+00, error=3.13e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.51e-13\n", - "Iteration 730, objective=5.45e-01, stepsize=8.00e+00, error=3.10e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 8.27e-13\n", - "Iteration 740, objective=5.44e-01, stepsize=1.60e+01, error=1.54e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.13e-12\n", - "Iteration 750, objective=5.44e-01, stepsize=8.00e+00, error=3.04e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.51e-13\n", - "Iteration 760, objective=5.44e-01, stepsize=1.60e+01, error=1.50e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.12e-12\n", - "Iteration 770, objective=5.44e-01, stepsize=8.00e+00, error=2.98e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.62e-13\n", - "Iteration 780, objective=5.43e-01, stepsize=8.00e+00, error=2.95e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.88e-13\n", - "Iteration 790, objective=5.43e-01, stepsize=8.00e+00, error=2.91e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.57e-13\n", - "Iteration 800, objective=5.43e-01, stepsize=8.00e+00, error=2.89e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.61e-13\n", - "Iteration 810, objective=5.42e-01, stepsize=1.60e+01, error=1.43e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.13e-12\n", - "Iteration 820, objective=5.42e-01, stepsize=8.00e+00, error=2.83e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.85e-13\n", - "Iteration 830, objective=5.42e-01, stepsize=1.60e+01, error=1.40e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.13e-12\n", - "Iteration 840, objective=5.42e-01, stepsize=8.00e+00, error=2.77e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.56e-13\n", - "Iteration 850, objective=5.41e-01, stepsize=1.60e+01, error=1.37e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.18e-12\n", - "Iteration 860, objective=5.41e-01, stepsize=8.00e+00, error=2.72e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.51e-13\n", - "Iteration 870, objective=5.41e-01, stepsize=1.60e+01, error=1.35e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.12e-12\n", - "Iteration 880, objective=5.41e-01, stepsize=8.00e+00, error=2.66e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.51e-13\n", - "Iteration 890, objective=5.41e-01, stepsize=1.60e+01, error=1.32e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.13e-12\n", - "Iteration 900, objective=5.40e-01, stepsize=8.00e+00, error=2.61e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.40e-13\n", - "Iteration 910, objective=5.40e-01, stepsize=8.00e+00, error=2.58e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.38e-13\n", - "Iteration 920, objective=5.40e-01, stepsize=8.00e+00, error=2.55e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.28e-13\n", - "Iteration 930, objective=5.40e-01, stepsize=8.00e+00, error=2.53e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.26e-13\n", - "Iteration 940, objective=5.40e-01, stepsize=1.60e+01, error=1.25e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.14e-12\n", - "Iteration 950, objective=5.40e-01, stepsize=8.00e+00, error=2.48e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.13e-13\n", - "Iteration 960, objective=5.39e-01, stepsize=1.60e+01, error=1.23e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.14e-12\n", - "Iteration 970, objective=5.39e-01, stepsize=8.00e+00, error=2.43e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.11e-13\n", - "Iteration 980, objective=5.39e-01, stepsize=1.60e+01, error=1.21e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.14e-12\n", - "Iteration 990, objective=5.39e-01, stepsize=8.00e+00, error=2.39e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.19e-13\n", - "Iteration 1000, objective=5.39e-01, stepsize=1.60e+01, error=1.18e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.15e-12\n", - "Iteration 1010, objective=5.39e-01, stepsize=8.00e+00, error=2.34e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.27e-13\n", - "Iteration 1020, objective=5.39e-01, stepsize=8.00e+00, error=2.32e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.52e-13\n", - "Iteration 1030, objective=5.38e-01, stepsize=8.00e+00, error=2.30e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.42e-13\n", - "Iteration 1040, objective=5.38e-01, stepsize=8.00e+00, error=2.28e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.67e-13\n", - "Iteration 1050, objective=5.38e-01, stepsize=8.00e+00, error=2.26e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.76e-13\n", - "Iteration 1060, objective=5.38e-01, stepsize=8.00e+00, error=2.24e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.04e-13\n", - "Iteration 1070, objective=5.38e-01, stepsize=8.00e+00, error=2.22e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.68e-13\n", - "Iteration 1080, objective=5.38e-01, stepsize=8.00e+00, error=2.20e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.75e-13\n", - "Iteration 1090, objective=5.38e-01, stepsize=8.00e+00, error=2.18e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.95e-13\n", - "Iteration 1100, objective=5.38e-01, stepsize=8.00e+00, error=2.16e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 8.25e-13\n", - "Iteration 1110, objective=5.38e-01, stepsize=8.00e+00, error=2.15e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 8.33e-13\n", - "Iteration 1120, objective=5.37e-01, stepsize=8.00e+00, error=2.13e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.41e-13\n", - "Iteration 1130, objective=5.37e-01, stepsize=8.00e+00, error=2.11e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.99e-13\n", - "Iteration 1140, objective=5.37e-01, stepsize=8.00e+00, error=2.09e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.01e-12\n", - "Iteration 1150, objective=5.37e-01, stepsize=8.00e+00, error=2.08e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.18e-12\n", - "Iteration 1160, objective=5.37e-01, stepsize=8.00e+00, error=2.06e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.75e-12\n", - "Iteration 1170, objective=5.37e-01, stepsize=1.60e+01, error=1.02e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.62e-12\n", - "Iteration 1180, objective=5.37e-01, stepsize=8.00e+00, error=2.03e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.87e-12\n", - "Iteration 1190, objective=5.37e-01, stepsize=1.60e+01, error=1.01e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.79e-12\n", - "Iteration 1200, objective=5.37e-01, stepsize=8.00e+00, error=2.01e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.84e-12\n", - "Iteration 1210, objective=5.37e-01, stepsize=8.00e+00, error=1.99e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.48e-12\n", - "Iteration 1220, objective=5.36e-01, stepsize=8.00e+00, error=1.98e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.40e-12\n", - "Iteration 1230, objective=5.36e-01, stepsize=8.00e+00, error=1.97e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.86e-13\n", - "Iteration 1240, objective=5.36e-01, stepsize=8.00e+00, error=1.95e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.56e-13\n", - "Iteration 1250, objective=5.36e-01, stepsize=8.00e+00, error=1.94e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.88e-13\n", - "Iteration 1260, objective=5.36e-01, stepsize=8.00e+00, error=1.93e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 8.36e-13\n", - "Iteration 1270, objective=5.36e-01, stepsize=1.60e+01, error=9.59e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.13e-12\n", - "Iteration 1280, objective=5.36e-01, stepsize=8.00e+00, error=1.90e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.11e-12\n", - "Iteration 1290, objective=5.36e-01, stepsize=1.60e+01, error=9.47e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.13e-12\n", - "Iteration 1300, objective=5.36e-01, stepsize=8.00e+00, error=1.88e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 8.22e-13\n", - "Iteration 1310, objective=5.36e-01, stepsize=1.60e+01, error=9.35e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.14e-12\n", - "Iteration 1320, objective=5.36e-01, stepsize=8.00e+00, error=1.86e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.36e-13\n", - "Iteration 1330, objective=5.36e-01, stepsize=1.60e+01, error=9.23e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.17e-12\n", - "Iteration 1340, objective=5.36e-01, stepsize=8.00e+00, error=1.83e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.58e-13\n", - "Iteration 1350, objective=5.36e-01, stepsize=1.60e+01, error=9.12e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.13e-12\n", - "Iteration 1360, objective=5.35e-01, stepsize=8.00e+00, error=1.81e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.12e-13\n", - "Iteration 1370, objective=5.35e-01, stepsize=1.60e+01, error=9.00e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.13e-12\n", - "Iteration 1380, objective=5.35e-01, stepsize=8.00e+00, error=1.79e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.17e-13\n", - "Iteration 1390, objective=5.35e-01, stepsize=1.60e+01, error=8.89e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.13e-12\n", - "Iteration 1400, objective=5.35e-01, stepsize=8.00e+00, error=1.77e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.36e-13\n", - "Iteration 1410, objective=5.35e-01, stepsize=1.60e+01, error=8.78e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.12e-12\n", - "Iteration 1420, objective=5.35e-01, stepsize=8.00e+00, error=1.74e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.55e-13\n", - "Iteration 1430, objective=5.35e-01, stepsize=1.60e+01, error=8.67e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.12e-12\n", - "Iteration 1440, objective=5.35e-01, stepsize=8.00e+00, error=1.72e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.78e-13\n", - "Iteration 1450, objective=5.35e-01, stepsize=1.60e+01, error=8.55e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.11e-12\n", - "Iteration 1460, objective=5.35e-01, stepsize=8.00e+00, error=1.70e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 8.33e-13\n", - "Iteration 1470, objective=5.35e-01, stepsize=1.60e+01, error=8.44e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.10e-12\n", - "Iteration 1480, objective=5.35e-01, stepsize=8.00e+00, error=1.68e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 8.79e-13\n", - "Iteration 1490, objective=5.35e-01, stepsize=1.60e+01, error=8.33e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.17e-12\n", - "Iteration 1500, objective=5.35e-01, stepsize=8.00e+00, error=1.65e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.19e-12\n", - "Iteration 1510, objective=5.35e-01, stepsize=1.60e+01, error=8.22e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 2.08e-12\n", - "Iteration 1520, objective=5.35e-01, stepsize=8.00e+00, error=1.63e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 8.29e-13\n", - "Iteration 1530, objective=5.35e-01, stepsize=1.60e+01, error=8.12e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.15e-12\n", - "Iteration 1540, objective=5.35e-01, stepsize=8.00e+00, error=1.61e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 8.30e-13\n", - "Iteration 1550, objective=5.35e-01, stepsize=8.00e+00, error=1.60e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 8.29e-13\n", - "Iteration 1560, objective=5.34e-01, stepsize=8.00e+00, error=1.59e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 8.28e-13\n", - "Iteration 1570, objective=5.34e-01, stepsize=8.00e+00, error=1.58e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 8.34e-13\n", - "Iteration 1580, objective=5.34e-01, stepsize=8.00e+00, error=1.57e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 8.24e-13\n", - "Iteration 1590, objective=5.34e-01, stepsize=8.00e+00, error=1.56e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 8.30e-13\n", - "Iteration 1600, objective=5.34e-01, stepsize=8.00e+00, error=1.55e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 1.98e-12\n", - "Iteration 1610, objective=5.34e-01, stepsize=8.00e+00, error=1.54e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 8.35e-13\n", - "Iteration 1620, objective=5.34e-01, stepsize=1.60e+01, error=7.65e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.11e-12\n", - "Iteration 1630, objective=5.34e-01, stepsize=8.00e+00, error=1.52e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 8.22e-13\n", - "Iteration 1640, objective=5.34e-01, stepsize=1.60e+01, error=7.55e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.10e-12\n", - "Iteration 1650, objective=5.34e-01, stepsize=8.00e+00, error=1.50e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.98e-13\n", - "Iteration 1660, objective=5.34e-01, stepsize=1.60e+01, error=7.46e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.10e-12\n", - "Iteration 1670, objective=5.34e-01, stepsize=8.00e+00, error=1.48e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.84e-13\n", - "Iteration 1680, objective=5.34e-01, stepsize=1.60e+01, error=7.36e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.10e-12\n", - "Iteration 1690, objective=5.34e-01, stepsize=8.00e+00, error=1.46e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.72e-13\n", - "Iteration 1700, objective=5.34e-01, stepsize=1.60e+01, error=7.26e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.11e-12\n", - "Iteration 1710, objective=5.34e-01, stepsize=8.00e+00, error=1.44e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.56e-13\n", - "Iteration 1720, objective=5.34e-01, stepsize=1.60e+01, error=7.17e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.12e-12\n", - "Iteration 1730, objective=5.34e-01, stepsize=8.00e+00, error=1.42e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.43e-13\n", - "Iteration 1740, objective=5.34e-01, stepsize=8.00e+00, error=1.41e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.46e-13\n", - "Iteration 1750, objective=5.34e-01, stepsize=8.00e+00, error=1.40e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.36e-13\n", - "Iteration 1760, objective=5.34e-01, stepsize=8.00e+00, error=1.40e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.46e-13\n", - "Iteration 1770, objective=5.34e-01, stepsize=1.60e+01, error=6.93e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.12e-12\n", - "Iteration 1780, objective=5.34e-01, stepsize=8.00e+00, error=1.38e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.61e-13\n", - "Iteration 1790, objective=5.34e-01, stepsize=1.60e+01, error=6.85e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.13e-12\n", - "Iteration 1800, objective=5.34e-01, stepsize=8.00e+00, error=1.36e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 8.01e-13\n", - "Iteration 1810, objective=5.34e-01, stepsize=1.60e+01, error=6.76e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.13e-12\n", - "Iteration 1820, objective=5.34e-01, stepsize=8.00e+00, error=1.34e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 8.35e-13\n", - "Iteration 1830, objective=5.34e-01, stepsize=1.60e+01, error=6.68e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.19e-12\n", - "Iteration 1840, objective=5.34e-01, stepsize=8.00e+00, error=1.33e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.88e-13\n", - "Iteration 1850, objective=5.34e-01, stepsize=8.00e+00, error=1.32e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.95e-13\n", - "Iteration 1860, objective=5.34e-01, stepsize=8.00e+00, error=1.31e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 8.02e-13\n", - "Iteration 1870, objective=5.34e-01, stepsize=8.00e+00, error=1.31e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 8.11e-13\n", - "Iteration 1880, objective=5.34e-01, stepsize=1.60e+01, error=6.50e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.12e-12\n", - "Iteration 1890, objective=5.34e-01, stepsize=8.00e+00, error=1.29e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 8.49e-13\n", - "Iteration 1900, objective=5.34e-01, stepsize=1.60e+01, error=6.43e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.16e-12\n", - "Iteration 1910, objective=5.34e-01, stepsize=8.00e+00, error=1.28e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.82e-13\n", - "Iteration 1920, objective=5.34e-01, stepsize=1.60e+01, error=6.37e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.21e-12\n", - "Iteration 1930, objective=5.33e-01, stepsize=8.00e+00, error=1.27e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.17e-13\n", - "Iteration 1940, objective=5.33e-01, stepsize=1.60e+01, error=6.32e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.25e-12\n", - "Iteration 1950, objective=5.33e-01, stepsize=8.00e+00, error=1.26e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 6.07e-13\n", - "Iteration 1960, objective=5.33e-01, stepsize=8.00e+00, error=1.25e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.37e-13\n", - "Iteration 1970, objective=5.33e-01, stepsize=8.00e+00, error=1.25e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 7.10e-13\n", - "Iteration 1980, objective=5.33e-01, stepsize=8.00e+00, error=1.24e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 8.26e-13\n", - "Iteration 1990, objective=5.33e-01, stepsize=1.60e+01, error=6.19e-03, shift sparsity = [0.95 1.00 0.93], duality gap = 1.30e-12\n", - "Iteration 2000, objective=5.33e-01, stepsize=8.00e+00, error=1.23e-02, shift sparsity = [0.95 1.00 0.93], duality gap = 8.19e-13\n" - ] - } - ], + "outputs": [], "source": [ "iter = []\n", "stepsize = []\n", @@ -2677,9 +2522,1641 @@ " )\n", "\n", "# update = jax.jit(solver.update)\n", - "update = solver.update\n", + "update = solver.update\n" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 10, objective=9.26e-01, stepsize=1.60e+01, error=3.71e-02, shift sparsity = [0.00 1.00 0.00], duality gap = 0.00e+00\n", + "Iteration 20, objective=8.66e-01, stepsize=1.60e+01, error=5.42e-02, shift sparsity = [0.00 1.00 0.00], duality gap = 0.00e+00\n", + "Iteration 30, objective=8.01e-01, stepsize=1.60e+01, error=6.37e-02, shift sparsity = [0.00 1.00 0.00], duality gap = 0.00e+00\n", + "Iteration 40, objective=7.37e-01, stepsize=1.60e+01, error=7.16e-02, shift sparsity = [0.00 1.00 0.00], duality gap = 0.00e+00\n", + "Iteration 50, objective=6.77e-01, stepsize=3.20e+01, error=3.96e-02, shift sparsity = [0.00 1.00 0.00], duality gap = 0.00e+00\n", + "Iteration 60, objective=6.19e-01, stepsize=1.60e+01, error=8.14e-02, shift sparsity = [0.00 1.00 0.00], duality gap = 0.00e+00\n", + "Iteration 70, objective=5.70e-01, stepsize=8.00e+00, error=1.56e-01, shift sparsity = [0.00 1.00 0.00], duality gap = 0.00e+00\n", + "Iteration 80, objective=5.33e-01, stepsize=1.60e+01, error=7.07e-02, shift sparsity = [0.00 1.00 0.00], duality gap = 0.00e+00\n", + "Iteration 90, objective=5.04e-01, stepsize=8.00e+00, error=1.32e-01, shift sparsity = [0.00 1.00 0.00], duality gap = 0.00e+00\n", + "Iteration 100, objective=4.78e-01, stepsize=1.60e+01, error=6.37e-02, shift sparsity = [0.00 1.00 0.00], duality gap = 0.00e+00\n", + "Iteration 110, objective=4.57e-01, stepsize=8.00e+00, error=1.19e-01, shift sparsity = [9.33e-04 1.00e+00 9.33e-04], duality gap = 0.00e+00\n", + "Iteration 120, objective=4.40e-01, stepsize=8.00e+00, error=1.13e-01, shift sparsity = [9.33e-04 1.00e+00 9.33e-04], duality gap = 0.00e+00\n", + "Iteration 130, objective=4.25e-01, stepsize=8.00e+00, error=1.07e-01, shift sparsity = [8.39e-04 1.00e+00 8.39e-04], duality gap = 0.00e+00\n", + "Iteration 140, objective=4.12e-01, stepsize=1.60e+01, error=5.16e-02, shift sparsity = [8.39e-04 1.00e+00 8.39e-04], duality gap = 0.00e+00\n", + "Iteration 150, objective=4.00e-01, stepsize=1.60e+01, error=4.97e-02, shift sparsity = [8.39e-04 1.00e+00 8.39e-04], duality gap = 0.00e+00\n", + "Iteration 160, objective=3.90e-01, stepsize=8.00e+00, error=9.44e-02, shift sparsity = [8.39e-04 1.00e+00 8.39e-04], duality gap = 0.00e+00\n", + "Iteration 170, objective=3.82e-01, stepsize=8.00e+00, error=9.20e-02, shift sparsity = [7.46e-04 1.00e+00 7.46e-04], duality gap = 0.00e+00\n", + "Iteration 180, objective=3.74e-01, stepsize=8.00e+00, error=8.84e-02, shift sparsity = [5.60e-04 1.00e+00 5.60e-04], duality gap = 0.00e+00\n", + "Iteration 190, objective=3.67e-01, stepsize=4.00e+00, error=1.71e-01, shift sparsity = [5.60e-04 1.00e+00 5.60e-04], duality gap = 0.00e+00\n", + "Iteration 200, objective=3.60e-01, stepsize=8.00e+00, error=8.32e-02, shift sparsity = [5.60e-04 1.00e+00 5.60e-04], duality gap = 0.00e+00\n", + "Iteration 210, objective=3.55e-01, stepsize=8.00e+00, error=8.09e-02, shift sparsity = [5.60e-04 1.00e+00 5.60e-04], duality gap = 0.00e+00\n", + "Iteration 220, objective=3.50e-01, stepsize=1.60e+01, error=3.97e-02, shift sparsity = [5.60e-04 1.00e+00 5.60e-04], duality gap = 0.00e+00\n", + "Iteration 230, objective=3.45e-01, stepsize=4.00e+00, error=1.54e-01, shift sparsity = [4.66e-04 1.00e+00 4.66e-04], duality gap = 0.00e+00\n", + "Iteration 240, objective=3.40e-01, stepsize=8.00e+00, error=7.50e-02, shift sparsity = [4.66e-04 1.00e+00 4.66e-04], duality gap = 0.00e+00\n", + "Iteration 250, objective=3.37e-01, stepsize=8.00e+00, error=7.33e-02, shift sparsity = [4.66e-04 1.00e+00 4.66e-04], duality gap = 0.00e+00\n", + "Iteration 260, objective=3.33e-01, stepsize=1.60e+01, error=3.62e-02, shift sparsity = [4.66e-04 1.00e+00 4.66e-04], duality gap = 0.00e+00\n", + "Iteration 270, objective=3.29e-01, stepsize=4.00e+00, error=1.42e-01, shift sparsity = [3.73e-04 1.00e+00 3.73e-04], duality gap = 0.00e+00\n", + "Iteration 280, objective=3.26e-01, stepsize=4.00e+00, error=1.39e-01, shift sparsity = [3.73e-04 1.00e+00 3.73e-04], duality gap = 0.00e+00\n", + "Iteration 290, objective=3.23e-01, stepsize=4.00e+00, error=1.36e-01, shift sparsity = [3.73e-04 1.00e+00 3.73e-04], duality gap = 0.00e+00\n", + "Iteration 300, objective=3.21e-01, stepsize=4.00e+00, error=1.34e-01, shift sparsity = [3.73e-04 1.00e+00 3.73e-04], duality gap = 0.00e+00\n", + "Iteration 310, objective=3.18e-01, stepsize=1.60e+01, error=3.31e-02, shift sparsity = [3.73e-04 1.00e+00 3.73e-04], duality gap = 0.00e+00\n", + "Iteration 320, objective=3.16e-01, stepsize=1.60e+01, error=3.25e-02, shift sparsity = [3.73e-04 1.00e+00 3.73e-04], duality gap = 0.00e+00\n", + "Iteration 330, objective=3.14e-01, stepsize=1.60e+01, error=3.19e-02, shift sparsity = [3.73e-04 1.00e+00 3.73e-04], duality gap = 0.00e+00\n", + "Iteration 340, objective=3.12e-01, stepsize=8.00e+00, error=6.24e-02, shift sparsity = [3.73e-04 1.00e+00 3.73e-04], duality gap = 0.00e+00\n", + "Iteration 350, objective=3.10e-01, stepsize=8.00e+00, error=6.14e-02, shift sparsity = [3.73e-04 1.00e+00 3.73e-04], duality gap = 0.00e+00\n", + "Iteration 360, objective=3.08e-01, stepsize=8.00e+00, error=6.05e-02, shift sparsity = [3.73e-04 1.00e+00 3.73e-04], duality gap = 0.00e+00\n", + "Iteration 370, objective=3.06e-01, stepsize=8.00e+00, error=5.96e-02, shift sparsity = [3.73e-04 1.00e+00 3.73e-04], duality gap = 0.00e+00\n", + "Iteration 380, objective=3.05e-01, stepsize=1.60e+01, error=2.95e-02, shift sparsity = [3.73e-04 1.00e+00 3.73e-04], duality gap = 0.00e+00\n", + "Iteration 390, objective=3.03e-01, stepsize=8.00e+00, error=5.77e-02, shift sparsity = [3.73e-04 1.00e+00 3.73e-04], duality gap = 0.00e+00\n", + "Iteration 400, objective=3.02e-01, stepsize=8.00e+00, error=5.70e-02, shift sparsity = [3.73e-04 1.00e+00 3.73e-04], duality gap = 0.00e+00\n", + "Iteration 410, objective=3.01e-01, stepsize=4.00e+00, error=1.12e-01, shift sparsity = [2.80e-04 1.00e+00 2.80e-04], duality gap = 0.00e+00\n", + "Iteration 420, objective=2.99e-01, stepsize=8.00e+00, error=5.53e-02, shift sparsity = [2.80e-04 1.00e+00 2.80e-04], duality gap = 0.00e+00\n", + "Iteration 430, objective=2.98e-01, stepsize=8.00e+00, error=5.46e-02, shift sparsity = [2.80e-04 1.00e+00 2.80e-04], duality gap = 0.00e+00\n", + "Iteration 440, objective=2.97e-01, stepsize=4.00e+00, error=1.08e-01, shift sparsity = [2.80e-04 1.00e+00 2.80e-04], duality gap = 0.00e+00\n", + "Iteration 450, objective=2.96e-01, stepsize=8.00e+00, error=5.31e-02, shift sparsity = [2.80e-04 1.00e+00 2.80e-04], duality gap = 0.00e+00\n", + "Iteration 460, objective=2.95e-01, stepsize=8.00e+00, error=5.25e-02, shift sparsity = [1.87e-04 1.00e+00 1.87e-04], duality gap = 0.00e+00\n", + "Iteration 470, objective=2.94e-01, stepsize=1.60e+01, error=2.60e-02, shift sparsity = [1.87e-04 1.00e+00 1.87e-04], duality gap = 0.00e+00\n", + "Iteration 480, objective=2.93e-01, stepsize=8.00e+00, error=5.11e-02, shift sparsity = [1.87e-04 1.00e+00 1.87e-04], duality gap = 0.00e+00\n", + "Iteration 490, objective=2.93e-01, stepsize=1.60e+01, error=2.53e-02, shift sparsity = [1.87e-04 1.00e+00 1.87e-04], duality gap = 0.00e+00\n", + "Iteration 500, objective=2.92e-01, stepsize=8.00e+00, error=4.98e-02, shift sparsity = [1.87e-04 1.00e+00 1.87e-04], duality gap = 0.00e+00\n", + "Iteration 510, objective=2.91e-01, stepsize=1.60e+01, error=2.47e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 520, objective=2.90e-01, stepsize=8.00e+00, error=4.86e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 530, objective=2.90e-01, stepsize=8.00e+00, error=4.80e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 540, objective=2.89e-01, stepsize=8.00e+00, error=4.75e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 550, objective=2.88e-01, stepsize=8.00e+00, error=4.69e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 560, objective=2.88e-01, stepsize=4.00e+00, error=9.27e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 570, objective=2.87e-01, stepsize=8.00e+00, error=4.57e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 580, objective=2.87e-01, stepsize=1.60e+01, error=2.27e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 590, objective=2.86e-01, stepsize=8.00e+00, error=4.47e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 600, objective=2.86e-01, stepsize=8.00e+00, error=4.41e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 610, objective=2.85e-01, stepsize=4.00e+00, error=8.73e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 620, objective=2.85e-01, stepsize=8.00e+00, error=4.31e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 630, objective=2.84e-01, stepsize=8.00e+00, error=4.26e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 640, objective=2.84e-01, stepsize=8.00e+00, error=4.21e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 650, objective=2.83e-01, stepsize=8.00e+00, error=4.16e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 660, objective=2.83e-01, stepsize=8.00e+00, error=4.12e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 670, objective=2.83e-01, stepsize=4.00e+00, error=8.15e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 680, objective=2.82e-01, stepsize=8.00e+00, error=4.03e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 690, objective=2.82e-01, stepsize=8.00e+00, error=3.99e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 700, objective=2.82e-01, stepsize=1.60e+01, error=1.98e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 710, objective=2.81e-01, stepsize=8.00e+00, error=3.91e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 720, objective=2.81e-01, stepsize=8.00e+00, error=3.87e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 730, objective=2.81e-01, stepsize=8.00e+00, error=3.83e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 740, objective=2.80e-01, stepsize=1.60e+01, error=1.90e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 750, objective=2.80e-01, stepsize=8.00e+00, error=3.75e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 760, objective=2.80e-01, stepsize=8.00e+00, error=3.71e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 770, objective=2.80e-01, stepsize=8.00e+00, error=3.67e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 780, objective=2.79e-01, stepsize=8.00e+00, error=3.63e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 790, objective=2.79e-01, stepsize=4.00e+00, error=7.18e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 800, objective=2.79e-01, stepsize=8.00e+00, error=3.54e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 810, objective=2.79e-01, stepsize=8.00e+00, error=3.49e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 820, objective=2.79e-01, stepsize=8.00e+00, error=3.44e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 830, objective=2.78e-01, stepsize=8.00e+00, error=3.39e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 840, objective=2.78e-01, stepsize=1.60e+01, error=1.67e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 850, objective=2.78e-01, stepsize=8.00e+00, error=3.28e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 860, objective=2.78e-01, stepsize=8.00e+00, error=3.22e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 870, objective=2.78e-01, stepsize=8.00e+00, error=3.16e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 880, objective=2.78e-01, stepsize=8.00e+00, error=3.10e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 890, objective=2.78e-01, stepsize=1.60e+01, error=1.52e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 900, objective=2.78e-01, stepsize=8.00e+00, error=2.97e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 910, objective=2.78e-01, stepsize=8.00e+00, error=2.90e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 920, objective=2.78e-01, stepsize=8.00e+00, error=2.83e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 930, objective=2.78e-01, stepsize=8.00e+00, error=2.76e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 940, objective=2.78e-01, stepsize=1.60e+01, error=1.35e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 950, objective=2.78e-01, stepsize=4.00e+00, error=5.24e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 960, objective=2.78e-01, stepsize=8.00e+00, error=2.54e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 970, objective=2.78e-01, stepsize=8.00e+00, error=2.47e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 980, objective=2.78e-01, stepsize=8.00e+00, error=2.39e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 990, objective=2.78e-01, stepsize=8.00e+00, error=2.32e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1000, objective=2.78e-01, stepsize=4.00e+00, error=4.49e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1010, objective=2.78e-01, stepsize=8.00e+00, error=2.17e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1020, objective=2.78e-01, stepsize=8.00e+00, error=2.10e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1030, objective=2.78e-01, stepsize=8.00e+00, error=2.03e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1040, objective=2.78e-01, stepsize=8.00e+00, error=1.96e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1050, objective=2.78e-01, stepsize=1.60e+01, error=9.44e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1060, objective=2.78e-01, stepsize=8.00e+00, error=1.82e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1070, objective=2.78e-01, stepsize=8.00e+00, error=1.76e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1080, objective=2.78e-01, stepsize=8.00e+00, error=1.70e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1090, objective=2.78e-01, stepsize=8.00e+00, error=1.65e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1100, objective=2.78e-01, stepsize=8.00e+00, error=1.60e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1110, objective=2.78e-01, stepsize=4.00e+00, error=3.11e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1120, objective=2.78e-01, stepsize=8.00e+00, error=1.51e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1130, objective=2.78e-01, stepsize=8.00e+00, error=1.48e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1140, objective=2.78e-01, stepsize=8.00e+00, error=1.45e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1150, objective=2.78e-01, stepsize=8.00e+00, error=1.42e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1160, objective=2.78e-01, stepsize=8.00e+00, error=1.40e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1170, objective=2.78e-01, stepsize=1.60e+01, error=6.96e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1180, objective=2.78e-01, stepsize=8.00e+00, error=1.38e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1190, objective=2.77e-01, stepsize=8.00e+00, error=1.38e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1200, objective=2.77e-01, stepsize=8.00e+00, error=1.38e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1210, objective=2.77e-01, stepsize=8.00e+00, error=1.38e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1220, objective=2.77e-01, stepsize=8.00e+00, error=1.39e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1230, objective=2.77e-01, stepsize=1.60e+01, error=7.02e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1240, objective=2.77e-01, stepsize=8.00e+00, error=1.41e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1250, objective=2.77e-01, stepsize=8.00e+00, error=1.43e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1260, objective=2.77e-01, stepsize=8.00e+00, error=1.44e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1270, objective=2.77e-01, stepsize=8.00e+00, error=1.46e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1280, objective=2.77e-01, stepsize=8.00e+00, error=1.48e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1290, objective=2.77e-01, stepsize=4.00e+00, error=2.99e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1300, objective=2.77e-01, stepsize=8.00e+00, error=1.51e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1310, objective=2.77e-01, stepsize=8.00e+00, error=1.53e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1320, objective=2.77e-01, stepsize=8.00e+00, error=1.54e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1330, objective=2.77e-01, stepsize=8.00e+00, error=1.55e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1340, objective=2.77e-01, stepsize=8.00e+00, error=1.56e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1350, objective=2.77e-01, stepsize=1.60e+01, error=7.86e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1360, objective=2.77e-01, stepsize=4.00e+00, error=3.15e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1370, objective=2.77e-01, stepsize=8.00e+00, error=1.58e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1380, objective=2.77e-01, stepsize=8.00e+00, error=1.58e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1390, objective=2.77e-01, stepsize=8.00e+00, error=1.58e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1400, objective=2.77e-01, stepsize=8.00e+00, error=1.57e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1410, objective=2.77e-01, stepsize=8.00e+00, error=1.56e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1420, objective=2.77e-01, stepsize=8.00e+00, error=1.55e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1430, objective=2.77e-01, stepsize=1.60e+01, error=7.71e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1440, objective=2.77e-01, stepsize=8.00e+00, error=1.53e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1450, objective=2.77e-01, stepsize=8.00e+00, error=1.51e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1460, objective=2.77e-01, stepsize=8.00e+00, error=1.49e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1470, objective=2.77e-01, stepsize=8.00e+00, error=1.46e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1480, objective=2.77e-01, stepsize=8.00e+00, error=1.44e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1490, objective=2.77e-01, stepsize=1.60e+01, error=7.06e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1500, objective=2.77e-01, stepsize=4.00e+00, error=2.77e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1510, objective=2.77e-01, stepsize=8.00e+00, error=1.35e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1520, objective=2.77e-01, stepsize=8.00e+00, error=1.32e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1530, objective=2.77e-01, stepsize=8.00e+00, error=1.29e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1540, objective=2.77e-01, stepsize=8.00e+00, error=1.25e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1550, objective=2.77e-01, stepsize=1.60e+01, error=6.08e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1560, objective=2.77e-01, stepsize=4.00e+00, error=2.37e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1570, objective=2.77e-01, stepsize=8.00e+00, error=1.15e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1580, objective=2.77e-01, stepsize=8.00e+00, error=1.11e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1590, objective=2.77e-01, stepsize=8.00e+00, error=1.08e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1600, objective=2.77e-01, stepsize=8.00e+00, error=1.05e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1610, objective=2.77e-01, stepsize=1.60e+01, error=5.06e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1620, objective=2.77e-01, stepsize=4.00e+00, error=1.97e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1630, objective=2.77e-01, stepsize=8.00e+00, error=9.54e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1640, objective=2.77e-01, stepsize=8.00e+00, error=9.27e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1650, objective=2.77e-01, stepsize=8.00e+00, error=9.02e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1660, objective=2.77e-01, stepsize=8.00e+00, error=8.79e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1670, objective=2.77e-01, stepsize=1.60e+01, error=4.29e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1680, objective=2.77e-01, stepsize=4.00e+00, error=1.68e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1690, objective=2.77e-01, stepsize=8.00e+00, error=8.28e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1700, objective=2.77e-01, stepsize=8.00e+00, error=8.17e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1710, objective=2.77e-01, stepsize=8.00e+00, error=8.08e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1720, objective=2.77e-01, stepsize=8.00e+00, error=8.02e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1730, objective=2.77e-01, stepsize=1.60e+01, error=4.00e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1740, objective=2.77e-01, stepsize=4.00e+00, error=1.60e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1750, objective=2.77e-01, stepsize=8.00e+00, error=7.98e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1760, objective=2.77e-01, stepsize=8.00e+00, error=8.01e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1770, objective=2.77e-01, stepsize=8.00e+00, error=8.04e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1780, objective=2.77e-01, stepsize=8.00e+00, error=8.09e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1790, objective=2.77e-01, stepsize=8.00e+00, error=8.14e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1800, objective=2.77e-01, stepsize=8.00e+00, error=8.19e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1810, objective=2.77e-01, stepsize=4.00e+00, error=1.65e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1820, objective=2.77e-01, stepsize=8.00e+00, error=8.32e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1830, objective=2.77e-01, stepsize=8.00e+00, error=8.37e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1840, objective=2.77e-01, stepsize=8.00e+00, error=8.42e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1850, objective=2.77e-01, stepsize=8.00e+00, error=8.47e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1860, objective=2.77e-01, stepsize=8.00e+00, error=8.51e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1870, objective=2.77e-01, stepsize=8.00e+00, error=8.54e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1880, objective=2.77e-01, stepsize=8.00e+00, error=8.56e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1890, objective=2.77e-01, stepsize=4.00e+00, error=1.72e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1900, objective=2.77e-01, stepsize=8.00e+00, error=8.59e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1910, objective=2.77e-01, stepsize=8.00e+00, error=8.59e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1920, objective=2.77e-01, stepsize=8.00e+00, error=8.58e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1930, objective=2.77e-01, stepsize=8.00e+00, error=8.56e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1940, objective=2.77e-01, stepsize=8.00e+00, error=8.53e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1950, objective=2.77e-01, stepsize=8.00e+00, error=8.49e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1960, objective=2.77e-01, stepsize=1.60e+01, error=4.23e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1970, objective=2.77e-01, stepsize=4.00e+00, error=1.68e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1980, objective=2.77e-01, stepsize=8.00e+00, error=8.35e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 1990, objective=2.77e-01, stepsize=8.00e+00, error=8.29e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2000, objective=2.77e-01, stepsize=8.00e+00, error=8.22e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2010, objective=2.77e-01, stepsize=8.00e+00, error=8.15e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2020, objective=2.77e-01, stepsize=8.00e+00, error=8.08e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2030, objective=2.77e-01, stepsize=1.60e+01, error=4.00e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2040, objective=2.77e-01, stepsize=4.00e+00, error=1.58e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2050, objective=2.77e-01, stepsize=8.00e+00, error=7.84e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2060, objective=2.77e-01, stepsize=8.00e+00, error=7.75e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2070, objective=2.77e-01, stepsize=8.00e+00, error=7.65e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2080, objective=2.77e-01, stepsize=8.00e+00, error=7.56e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2090, objective=2.76e-01, stepsize=1.60e+01, error=3.73e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2100, objective=2.76e-01, stepsize=4.00e+00, error=1.47e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2110, objective=2.76e-01, stepsize=8.00e+00, error=7.25e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2120, objective=2.76e-01, stepsize=8.00e+00, error=7.14e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2130, objective=2.76e-01, stepsize=8.00e+00, error=7.03e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2140, objective=2.76e-01, stepsize=8.00e+00, error=6.92e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2150, objective=2.76e-01, stepsize=8.00e+00, error=6.80e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2160, objective=2.76e-01, stepsize=4.00e+00, error=1.34e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2170, objective=2.76e-01, stepsize=8.00e+00, error=6.58e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2180, objective=2.77e-01, stepsize=8.00e+00, error=6.47e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2190, objective=2.77e-01, stepsize=8.00e+00, error=6.36e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2200, objective=2.77e-01, stepsize=8.00e+00, error=6.25e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2210, objective=2.77e-01, stepsize=8.00e+00, error=6.15e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2220, objective=2.77e-01, stepsize=4.00e+00, error=1.21e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2230, objective=2.77e-01, stepsize=8.00e+00, error=5.96e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2240, objective=2.77e-01, stepsize=8.00e+00, error=5.88e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2250, objective=2.77e-01, stepsize=8.00e+00, error=5.81e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2260, objective=2.77e-01, stepsize=8.00e+00, error=5.74e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2270, objective=2.77e-01, stepsize=1.60e+01, error=2.84e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2280, objective=2.77e-01, stepsize=4.00e+00, error=1.13e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2290, objective=2.77e-01, stepsize=8.00e+00, error=5.62e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2300, objective=2.77e-01, stepsize=8.00e+00, error=5.60e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2310, objective=2.77e-01, stepsize=8.00e+00, error=5.60e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2320, objective=2.77e-01, stepsize=8.00e+00, error=5.61e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2330, objective=2.77e-01, stepsize=8.00e+00, error=5.64e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2340, objective=2.77e-01, stepsize=4.00e+00, error=1.13e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2350, objective=2.77e-01, stepsize=8.00e+00, error=5.72e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2360, objective=2.76e-01, stepsize=8.00e+00, error=5.78e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2370, objective=2.76e-01, stepsize=8.00e+00, error=5.84e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2380, objective=2.76e-01, stepsize=8.00e+00, error=5.91e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2390, objective=2.76e-01, stepsize=8.00e+00, error=5.99e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2400, objective=2.76e-01, stepsize=8.00e+00, error=6.06e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2410, objective=2.76e-01, stepsize=1.60e+01, error=3.08e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2420, objective=2.76e-01, stepsize=4.00e+00, error=1.25e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2430, objective=2.76e-01, stepsize=8.00e+00, error=6.31e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2440, objective=2.76e-01, stepsize=8.00e+00, error=6.39e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2450, objective=2.76e-01, stepsize=8.00e+00, error=6.47e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2460, objective=2.76e-01, stepsize=8.00e+00, error=6.54e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2470, objective=2.76e-01, stepsize=8.00e+00, error=6.60e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2480, objective=2.76e-01, stepsize=8.00e+00, error=6.66e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2490, objective=2.76e-01, stepsize=8.00e+00, error=6.71e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2500, objective=2.76e-01, stepsize=1.60e+01, error=3.38e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2510, objective=2.76e-01, stepsize=4.00e+00, error=1.36e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2520, objective=2.76e-01, stepsize=8.00e+00, error=6.82e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2530, objective=2.76e-01, stepsize=8.00e+00, error=6.83e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2540, objective=2.76e-01, stepsize=8.00e+00, error=6.84e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2550, objective=2.76e-01, stepsize=8.00e+00, error=6.84e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2560, objective=2.76e-01, stepsize=8.00e+00, error=6.84e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2570, objective=2.76e-01, stepsize=8.00e+00, error=6.82e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2580, objective=2.76e-01, stepsize=1.60e+01, error=3.40e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2590, objective=2.76e-01, stepsize=8.00e+00, error=6.76e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2600, objective=2.76e-01, stepsize=8.00e+00, error=6.71e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2610, objective=2.76e-01, stepsize=8.00e+00, error=6.66e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2620, objective=2.76e-01, stepsize=8.00e+00, error=6.61e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2630, objective=2.76e-01, stepsize=8.00e+00, error=6.54e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2640, objective=2.76e-01, stepsize=1.60e+01, error=3.23e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2650, objective=2.76e-01, stepsize=8.00e+00, error=6.39e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2660, objective=2.76e-01, stepsize=8.00e+00, error=6.31e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2670, objective=2.76e-01, stepsize=8.00e+00, error=6.23e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2680, objective=2.76e-01, stepsize=8.00e+00, error=6.14e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2690, objective=2.76e-01, stepsize=8.00e+00, error=6.05e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2700, objective=2.76e-01, stepsize=1.60e+01, error=2.97e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2710, objective=2.76e-01, stepsize=8.00e+00, error=5.85e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2720, objective=2.76e-01, stepsize=8.00e+00, error=5.75e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2730, objective=2.76e-01, stepsize=8.00e+00, error=5.66e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2740, objective=2.76e-01, stepsize=8.00e+00, error=5.56e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2750, objective=2.76e-01, stepsize=8.00e+00, error=5.47e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2760, objective=2.76e-01, stepsize=1.60e+01, error=2.68e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2770, objective=2.76e-01, stepsize=4.00e+00, error=1.06e-02, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2780, objective=2.76e-01, stepsize=8.00e+00, error=5.20e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2790, objective=2.76e-01, stepsize=8.00e+00, error=5.12e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2800, objective=2.76e-01, stepsize=8.00e+00, error=5.05e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2810, objective=2.76e-01, stepsize=8.00e+00, error=4.98e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2820, objective=2.76e-01, stepsize=8.00e+00, error=4.92e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2830, objective=2.76e-01, stepsize=4.00e+00, error=9.72e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2840, objective=2.76e-01, stepsize=8.00e+00, error=4.81e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2850, objective=2.76e-01, stepsize=8.00e+00, error=4.77e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2860, objective=2.76e-01, stepsize=8.00e+00, error=4.74e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2870, objective=2.76e-01, stepsize=8.00e+00, error=4.71e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2880, objective=2.76e-01, stepsize=8.00e+00, error=4.69e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2890, objective=2.76e-01, stepsize=8.00e+00, error=4.68e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2900, objective=2.76e-01, stepsize=1.60e+01, error=2.34e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2910, objective=2.76e-01, stepsize=8.00e+00, error=4.67e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2920, objective=2.76e-01, stepsize=8.00e+00, error=4.67e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2930, objective=2.76e-01, stepsize=8.00e+00, error=4.67e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2940, objective=2.76e-01, stepsize=8.00e+00, error=4.68e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2950, objective=2.76e-01, stepsize=8.00e+00, error=4.69e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2960, objective=2.76e-01, stepsize=8.00e+00, error=4.70e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2970, objective=2.76e-01, stepsize=8.00e+00, error=4.71e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2980, objective=2.76e-01, stepsize=1.60e+01, error=2.37e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 2990, objective=2.76e-01, stepsize=4.00e+00, error=9.49e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3000, objective=2.76e-01, stepsize=8.00e+00, error=4.76e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3010, objective=2.76e-01, stepsize=8.00e+00, error=4.77e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3020, objective=2.76e-01, stepsize=8.00e+00, error=4.78e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3030, objective=2.76e-01, stepsize=8.00e+00, error=4.79e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3040, objective=2.76e-01, stepsize=8.00e+00, error=4.79e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3050, objective=2.76e-01, stepsize=8.00e+00, error=4.79e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3060, objective=2.76e-01, stepsize=8.00e+00, error=4.80e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3070, objective=2.76e-01, stepsize=1.60e+01, error=2.40e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3080, objective=2.76e-01, stepsize=4.00e+00, error=9.58e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3090, objective=2.76e-01, stepsize=8.00e+00, error=4.78e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3100, objective=2.76e-01, stepsize=8.00e+00, error=4.77e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3110, objective=2.76e-01, stepsize=8.00e+00, error=4.75e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3120, objective=2.76e-01, stepsize=8.00e+00, error=4.73e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3130, objective=2.76e-01, stepsize=8.00e+00, error=4.71e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3140, objective=2.76e-01, stepsize=8.00e+00, error=4.69e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3150, objective=2.76e-01, stepsize=4.00e+00, error=9.33e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3160, objective=2.76e-01, stepsize=8.00e+00, error=4.64e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3170, objective=2.76e-01, stepsize=8.00e+00, error=4.61e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3180, objective=2.76e-01, stepsize=8.00e+00, error=4.58e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3190, objective=2.76e-01, stepsize=8.00e+00, error=4.55e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3200, objective=2.76e-01, stepsize=8.00e+00, error=4.52e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3210, objective=2.76e-01, stepsize=8.00e+00, error=4.49e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3220, objective=2.76e-01, stepsize=4.00e+00, error=8.93e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3230, objective=2.76e-01, stepsize=8.00e+00, error=4.44e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3240, objective=2.76e-01, stepsize=8.00e+00, error=4.41e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3250, objective=2.76e-01, stepsize=8.00e+00, error=4.38e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3260, objective=2.76e-01, stepsize=8.00e+00, error=4.36e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3270, objective=2.76e-01, stepsize=8.00e+00, error=4.33e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3280, objective=2.76e-01, stepsize=8.00e+00, error=4.31e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3290, objective=2.76e-01, stepsize=1.60e+01, error=2.15e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3300, objective=2.76e-01, stepsize=8.00e+00, error=4.28e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3310, objective=2.76e-01, stepsize=8.00e+00, error=4.27e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3320, objective=2.76e-01, stepsize=8.00e+00, error=4.26e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3330, objective=2.76e-01, stepsize=8.00e+00, error=4.25e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3340, objective=2.76e-01, stepsize=8.00e+00, error=4.24e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3350, objective=2.76e-01, stepsize=8.00e+00, error=4.24e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3360, objective=2.76e-01, stepsize=1.60e+01, error=2.12e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3370, objective=2.76e-01, stepsize=4.00e+00, error=8.49e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3380, objective=2.76e-01, stepsize=8.00e+00, error=4.25e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3390, objective=2.76e-01, stepsize=8.00e+00, error=4.26e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3400, objective=2.76e-01, stepsize=8.00e+00, error=4.27e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3410, objective=2.76e-01, stepsize=8.00e+00, error=4.29e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3420, objective=2.76e-01, stepsize=8.00e+00, error=4.30e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3430, objective=2.76e-01, stepsize=8.00e+00, error=4.32e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3440, objective=2.76e-01, stepsize=1.60e+01, error=2.17e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3450, objective=2.76e-01, stepsize=4.00e+00, error=8.72e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3460, objective=2.76e-01, stepsize=8.00e+00, error=4.38e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3470, objective=2.76e-01, stepsize=8.00e+00, error=4.40e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3480, objective=2.76e-01, stepsize=8.00e+00, error=4.43e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3490, objective=2.76e-01, stepsize=8.00e+00, error=4.46e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3500, objective=2.76e-01, stepsize=8.00e+00, error=4.48e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3510, objective=2.76e-01, stepsize=8.00e+00, error=4.51e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3520, objective=2.76e-01, stepsize=1.60e+01, error=2.27e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3530, objective=2.76e-01, stepsize=4.00e+00, error=9.12e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3540, objective=2.76e-01, stepsize=8.00e+00, error=4.58e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3550, objective=2.76e-01, stepsize=8.00e+00, error=4.61e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3560, objective=2.76e-01, stepsize=8.00e+00, error=4.63e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3570, objective=2.76e-01, stepsize=8.00e+00, error=4.66e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3580, objective=2.76e-01, stepsize=8.00e+00, error=4.68e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3590, objective=2.76e-01, stepsize=8.00e+00, error=4.70e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3600, objective=2.76e-01, stepsize=1.60e+01, error=2.36e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3610, objective=2.76e-01, stepsize=4.00e+00, error=9.46e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3620, objective=2.76e-01, stepsize=8.00e+00, error=4.74e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3630, objective=2.76e-01, stepsize=8.00e+00, error=4.75e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3640, objective=2.76e-01, stepsize=8.00e+00, error=4.76e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3650, objective=2.76e-01, stepsize=8.00e+00, error=4.76e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3660, objective=2.76e-01, stepsize=8.00e+00, error=4.77e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3670, objective=2.76e-01, stepsize=8.00e+00, error=4.77e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3680, objective=2.76e-01, stepsize=1.60e+01, error=2.38e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3690, objective=2.76e-01, stepsize=4.00e+00, error=9.51e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3700, objective=2.76e-01, stepsize=8.00e+00, error=4.75e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3710, objective=2.76e-01, stepsize=8.00e+00, error=4.73e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3720, objective=2.76e-01, stepsize=8.00e+00, error=4.72e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3730, objective=2.76e-01, stepsize=8.00e+00, error=4.70e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3740, objective=2.76e-01, stepsize=8.00e+00, error=4.68e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3750, objective=2.76e-01, stepsize=8.00e+00, error=4.65e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3760, objective=2.76e-01, stepsize=1.60e+01, error=2.31e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3770, objective=2.76e-01, stepsize=8.00e+00, error=4.60e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3780, objective=2.76e-01, stepsize=8.00e+00, error=4.57e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3790, objective=2.76e-01, stepsize=8.00e+00, error=4.53e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3800, objective=2.76e-01, stepsize=8.00e+00, error=4.50e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3810, objective=2.76e-01, stepsize=8.00e+00, error=4.46e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3820, objective=2.76e-01, stepsize=8.00e+00, error=4.43e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3830, objective=2.76e-01, stepsize=1.60e+01, error=2.19e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3840, objective=2.76e-01, stepsize=8.00e+00, error=4.35e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3850, objective=2.76e-01, stepsize=8.00e+00, error=4.31e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3860, objective=2.76e-01, stepsize=8.00e+00, error=4.27e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3870, objective=2.76e-01, stepsize=8.00e+00, error=4.23e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3880, objective=2.76e-01, stepsize=8.00e+00, error=4.19e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3890, objective=2.76e-01, stepsize=8.00e+00, error=4.16e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3900, objective=2.76e-01, stepsize=1.60e+01, error=2.06e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3910, objective=2.76e-01, stepsize=8.00e+00, error=4.08e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3920, objective=2.76e-01, stepsize=8.00e+00, error=4.05e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3930, objective=2.76e-01, stepsize=8.00e+00, error=4.02e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3940, objective=2.76e-01, stepsize=8.00e+00, error=3.99e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3950, objective=2.76e-01, stepsize=8.00e+00, error=3.97e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3960, objective=2.76e-01, stepsize=8.00e+00, error=3.94e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3970, objective=2.76e-01, stepsize=1.60e+01, error=1.96e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3980, objective=2.76e-01, stepsize=8.00e+00, error=3.91e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 3990, objective=2.76e-01, stepsize=8.00e+00, error=3.89e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4000, objective=2.76e-01, stepsize=8.00e+00, error=3.88e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4010, objective=2.76e-01, stepsize=8.00e+00, error=3.87e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4020, objective=2.76e-01, stepsize=8.00e+00, error=3.87e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4030, objective=2.76e-01, stepsize=8.00e+00, error=3.86e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4040, objective=2.76e-01, stepsize=1.60e+01, error=1.93e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4050, objective=2.76e-01, stepsize=4.00e+00, error=7.72e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4060, objective=2.76e-01, stepsize=8.00e+00, error=3.87e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4070, objective=2.76e-01, stepsize=8.00e+00, error=3.87e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4080, objective=2.76e-01, stepsize=8.00e+00, error=3.87e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4090, objective=2.76e-01, stepsize=8.00e+00, error=3.88e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4100, objective=2.76e-01, stepsize=8.00e+00, error=3.89e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4110, objective=2.76e-01, stepsize=8.00e+00, error=3.89e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4120, objective=2.76e-01, stepsize=8.00e+00, error=3.90e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4130, objective=2.76e-01, stepsize=1.60e+01, error=1.95e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4140, objective=2.76e-01, stepsize=4.00e+00, error=7.82e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4150, objective=2.76e-01, stepsize=8.00e+00, error=3.91e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4160, objective=2.76e-01, stepsize=8.00e+00, error=3.92e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4170, objective=2.76e-01, stepsize=8.00e+00, error=3.92e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4180, objective=2.76e-01, stepsize=8.00e+00, error=3.92e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4190, objective=2.76e-01, stepsize=8.00e+00, error=3.91e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4200, objective=2.76e-01, stepsize=8.00e+00, error=3.91e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4210, objective=2.76e-01, stepsize=8.00e+00, error=3.91e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4220, objective=2.76e-01, stepsize=8.00e+00, error=3.90e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4230, objective=2.76e-01, stepsize=1.60e+01, error=1.94e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4240, objective=2.76e-01, stepsize=8.00e+00, error=3.88e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4250, objective=2.76e-01, stepsize=8.00e+00, error=3.86e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4260, objective=2.76e-01, stepsize=8.00e+00, error=3.85e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4270, objective=2.76e-01, stepsize=8.00e+00, error=3.83e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4280, objective=2.76e-01, stepsize=8.00e+00, error=3.82e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4290, objective=2.76e-01, stepsize=8.00e+00, error=3.80e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4300, objective=2.76e-01, stepsize=8.00e+00, error=3.78e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4310, objective=2.76e-01, stepsize=1.60e+01, error=1.88e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4320, objective=2.76e-01, stepsize=8.00e+00, error=3.74e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4330, objective=2.76e-01, stepsize=8.00e+00, error=3.72e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4340, objective=2.76e-01, stepsize=8.00e+00, error=3.70e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4350, objective=2.76e-01, stepsize=8.00e+00, error=3.68e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4360, objective=2.76e-01, stepsize=8.00e+00, error=3.66e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4370, objective=2.76e-01, stepsize=8.00e+00, error=3.65e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4380, objective=2.76e-01, stepsize=1.60e+01, error=1.81e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4390, objective=2.76e-01, stepsize=4.00e+00, error=7.22e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4400, objective=2.76e-01, stepsize=8.00e+00, error=3.60e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4410, objective=2.76e-01, stepsize=8.00e+00, error=3.58e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4420, objective=2.76e-01, stepsize=8.00e+00, error=3.57e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4430, objective=2.76e-01, stepsize=8.00e+00, error=3.56e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4440, objective=2.76e-01, stepsize=8.00e+00, error=3.56e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4450, objective=2.76e-01, stepsize=8.00e+00, error=3.55e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4460, objective=2.76e-01, stepsize=1.60e+01, error=1.77e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4470, objective=2.76e-01, stepsize=4.00e+00, error=7.09e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4480, objective=2.76e-01, stepsize=8.00e+00, error=3.54e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4490, objective=2.76e-01, stepsize=8.00e+00, error=3.55e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4500, objective=2.76e-01, stepsize=8.00e+00, error=3.55e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4510, objective=2.76e-01, stepsize=8.00e+00, error=3.56e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4520, objective=2.76e-01, stepsize=8.00e+00, error=3.56e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4530, objective=2.76e-01, stepsize=8.00e+00, error=3.57e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4540, objective=2.76e-01, stepsize=1.60e+01, error=1.79e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4550, objective=2.76e-01, stepsize=4.00e+00, error=7.19e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4560, objective=2.76e-01, stepsize=8.00e+00, error=3.61e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4570, objective=2.76e-01, stepsize=8.00e+00, error=3.62e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4580, objective=2.76e-01, stepsize=8.00e+00, error=3.64e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4590, objective=2.76e-01, stepsize=8.00e+00, error=3.65e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4600, objective=2.76e-01, stepsize=8.00e+00, error=3.67e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4610, objective=2.76e-01, stepsize=8.00e+00, error=3.69e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4620, objective=2.76e-01, stepsize=1.60e+01, error=1.85e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4630, objective=2.76e-01, stepsize=4.00e+00, error=7.44e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4640, objective=2.76e-01, stepsize=8.00e+00, error=3.74e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4650, objective=2.76e-01, stepsize=8.00e+00, error=3.75e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4660, objective=2.76e-01, stepsize=8.00e+00, error=3.77e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4670, objective=2.76e-01, stepsize=8.00e+00, error=3.78e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4680, objective=2.76e-01, stepsize=8.00e+00, error=3.80e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4690, objective=2.76e-01, stepsize=8.00e+00, error=3.81e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4700, objective=2.76e-01, stepsize=8.00e+00, error=3.82e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4710, objective=2.76e-01, stepsize=1.60e+01, error=1.92e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4720, objective=2.76e-01, stepsize=8.00e+00, error=3.84e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4730, objective=2.76e-01, stepsize=8.00e+00, error=3.85e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4740, objective=2.76e-01, stepsize=8.00e+00, error=3.85e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4750, objective=2.76e-01, stepsize=8.00e+00, error=3.86e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4760, objective=2.76e-01, stepsize=8.00e+00, error=3.86e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4770, objective=2.76e-01, stepsize=8.00e+00, error=3.86e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4780, objective=2.76e-01, stepsize=1.60e+01, error=1.93e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4790, objective=2.76e-01, stepsize=4.00e+00, error=7.72e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4800, objective=2.76e-01, stepsize=8.00e+00, error=3.86e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4810, objective=2.76e-01, stepsize=8.00e+00, error=3.85e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4820, objective=2.76e-01, stepsize=8.00e+00, error=3.84e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4830, objective=2.76e-01, stepsize=8.00e+00, error=3.84e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4840, objective=2.76e-01, stepsize=8.00e+00, error=3.83e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4850, objective=2.76e-01, stepsize=1.60e+01, error=1.91e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4860, objective=2.76e-01, stepsize=4.00e+00, error=7.60e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4870, objective=2.76e-01, stepsize=8.00e+00, error=3.79e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4880, objective=2.76e-01, stepsize=8.00e+00, error=3.77e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4890, objective=2.76e-01, stepsize=8.00e+00, error=3.75e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4900, objective=2.76e-01, stepsize=8.00e+00, error=3.73e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4910, objective=2.76e-01, stepsize=8.00e+00, error=3.72e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4920, objective=2.76e-01, stepsize=8.00e+00, error=3.70e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4930, objective=2.76e-01, stepsize=4.00e+00, error=7.35e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4940, objective=2.76e-01, stepsize=8.00e+00, error=3.65e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4950, objective=2.76e-01, stepsize=8.00e+00, error=3.63e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4960, objective=2.76e-01, stepsize=8.00e+00, error=3.61e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4970, objective=2.76e-01, stepsize=8.00e+00, error=3.59e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4980, objective=2.76e-01, stepsize=8.00e+00, error=3.56e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 4990, objective=2.76e-01, stepsize=8.00e+00, error=3.54e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5000, objective=2.76e-01, stepsize=1.60e+01, error=1.76e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5010, objective=2.76e-01, stepsize=4.00e+00, error=6.99e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5020, objective=2.76e-01, stepsize=8.00e+00, error=3.47e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5030, objective=2.76e-01, stepsize=8.00e+00, error=3.45e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5040, objective=2.76e-01, stepsize=8.00e+00, error=3.43e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5050, objective=2.76e-01, stepsize=8.00e+00, error=3.41e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5060, objective=2.76e-01, stepsize=8.00e+00, error=3.39e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5070, objective=2.76e-01, stepsize=8.00e+00, error=3.37e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5080, objective=2.76e-01, stepsize=1.60e+01, error=1.68e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5090, objective=2.76e-01, stepsize=4.00e+00, error=6.67e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5100, objective=2.76e-01, stepsize=8.00e+00, error=3.32e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5110, objective=2.76e-01, stepsize=8.00e+00, error=3.30e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5120, objective=2.76e-01, stepsize=8.00e+00, error=3.29e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5130, objective=2.76e-01, stepsize=8.00e+00, error=3.28e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5140, objective=2.76e-01, stepsize=8.00e+00, error=3.26e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5150, objective=2.76e-01, stepsize=8.00e+00, error=3.25e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5160, objective=2.76e-01, stepsize=8.00e+00, error=3.24e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5170, objective=2.76e-01, stepsize=1.60e+01, error=1.61e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5180, objective=2.76e-01, stepsize=4.00e+00, error=6.44e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5190, objective=2.76e-01, stepsize=4.00e+00, error=6.42e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5200, objective=2.76e-01, stepsize=8.00e+00, error=3.20e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5210, objective=2.76e-01, stepsize=8.00e+00, error=3.20e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5220, objective=2.76e-01, stepsize=8.00e+00, error=3.19e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5230, objective=2.76e-01, stepsize=8.00e+00, error=3.18e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5240, objective=2.76e-01, stepsize=8.00e+00, error=3.18e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5250, objective=2.76e-01, stepsize=8.00e+00, error=3.17e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5260, objective=2.76e-01, stepsize=8.00e+00, error=3.16e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5270, objective=2.76e-01, stepsize=8.00e+00, error=3.16e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5280, objective=2.76e-01, stepsize=1.60e+01, error=1.57e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5290, objective=2.76e-01, stepsize=4.00e+00, error=6.28e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5300, objective=2.76e-01, stepsize=8.00e+00, error=3.13e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5310, objective=2.76e-01, stepsize=8.00e+00, error=3.13e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5320, objective=2.76e-01, stepsize=8.00e+00, error=3.12e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5330, objective=2.76e-01, stepsize=8.00e+00, error=3.11e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5340, objective=2.76e-01, stepsize=8.00e+00, error=3.10e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5350, objective=2.76e-01, stepsize=8.00e+00, error=3.09e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5360, objective=2.76e-01, stepsize=8.00e+00, error=3.08e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5370, objective=2.76e-01, stepsize=8.00e+00, error=3.07e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5380, objective=2.76e-01, stepsize=1.60e+01, error=1.53e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5390, objective=2.76e-01, stepsize=4.00e+00, error=6.09e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5400, objective=2.76e-01, stepsize=8.00e+00, error=3.03e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5410, objective=2.76e-01, stepsize=8.00e+00, error=3.02e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5420, objective=2.76e-01, stepsize=8.00e+00, error=3.01e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5430, objective=2.76e-01, stepsize=8.00e+00, error=2.99e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5440, objective=2.76e-01, stepsize=8.00e+00, error=2.98e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5450, objective=2.76e-01, stepsize=8.00e+00, error=2.97e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5460, objective=2.76e-01, stepsize=1.60e+01, error=1.48e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5470, objective=2.76e-01, stepsize=4.00e+00, error=5.89e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5480, objective=2.76e-01, stepsize=8.00e+00, error=2.93e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5490, objective=2.76e-01, stepsize=8.00e+00, error=2.92e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5500, objective=2.76e-01, stepsize=8.00e+00, error=2.91e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5510, objective=2.76e-01, stepsize=8.00e+00, error=2.90e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5520, objective=2.76e-01, stepsize=8.00e+00, error=2.90e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5530, objective=2.76e-01, stepsize=8.00e+00, error=2.89e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5540, objective=2.76e-01, stepsize=1.60e+01, error=1.44e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5550, objective=2.76e-01, stepsize=4.00e+00, error=5.76e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5560, objective=2.76e-01, stepsize=8.00e+00, error=2.88e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5570, objective=2.76e-01, stepsize=8.00e+00, error=2.87e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5580, objective=2.76e-01, stepsize=8.00e+00, error=2.87e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5590, objective=2.76e-01, stepsize=8.00e+00, error=2.88e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5600, objective=2.76e-01, stepsize=8.00e+00, error=2.88e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5610, objective=2.76e-01, stepsize=8.00e+00, error=2.88e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5620, objective=2.76e-01, stepsize=1.60e+01, error=1.44e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5630, objective=2.76e-01, stepsize=4.00e+00, error=5.79e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5640, objective=2.76e-01, stepsize=8.00e+00, error=2.90e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5650, objective=2.76e-01, stepsize=8.00e+00, error=2.91e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5660, objective=2.76e-01, stepsize=8.00e+00, error=2.92e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5670, objective=2.76e-01, stepsize=8.00e+00, error=2.93e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5680, objective=2.76e-01, stepsize=8.00e+00, error=2.94e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5690, objective=2.76e-01, stepsize=8.00e+00, error=2.95e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5700, objective=2.76e-01, stepsize=8.00e+00, error=2.96e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5710, objective=2.76e-01, stepsize=8.00e+00, error=2.97e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5720, objective=2.76e-01, stepsize=1.60e+01, error=1.49e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5730, objective=2.76e-01, stepsize=4.00e+00, error=5.98e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5740, objective=2.76e-01, stepsize=8.00e+00, error=3.00e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5750, objective=2.76e-01, stepsize=8.00e+00, error=3.01e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5760, objective=2.76e-01, stepsize=8.00e+00, error=3.02e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5770, objective=2.76e-01, stepsize=8.00e+00, error=3.03e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5780, objective=2.76e-01, stepsize=8.00e+00, error=3.04e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5790, objective=2.76e-01, stepsize=8.00e+00, error=3.05e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5800, objective=2.76e-01, stepsize=8.00e+00, error=3.06e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5810, objective=2.76e-01, stepsize=1.60e+01, error=1.53e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5820, objective=2.76e-01, stepsize=4.00e+00, error=6.13e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5830, objective=2.76e-01, stepsize=8.00e+00, error=3.07e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5840, objective=2.76e-01, stepsize=8.00e+00, error=3.07e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5850, objective=2.76e-01, stepsize=8.00e+00, error=3.07e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5860, objective=2.76e-01, stepsize=8.00e+00, error=3.07e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5870, objective=2.76e-01, stepsize=8.00e+00, error=3.07e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5880, objective=2.76e-01, stepsize=8.00e+00, error=3.07e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5890, objective=2.76e-01, stepsize=1.60e+01, error=1.53e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5900, objective=2.76e-01, stepsize=4.00e+00, error=6.12e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5910, objective=2.76e-01, stepsize=8.00e+00, error=3.06e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5920, objective=2.76e-01, stepsize=8.00e+00, error=3.05e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5930, objective=2.76e-01, stepsize=8.00e+00, error=3.04e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5940, objective=2.76e-01, stepsize=8.00e+00, error=3.03e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5950, objective=2.76e-01, stepsize=8.00e+00, error=3.02e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5960, objective=2.76e-01, stepsize=8.00e+00, error=3.01e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5970, objective=2.76e-01, stepsize=1.60e+01, error=1.50e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5980, objective=2.76e-01, stepsize=4.00e+00, error=5.97e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 5990, objective=2.76e-01, stepsize=8.00e+00, error=2.97e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6000, objective=2.76e-01, stepsize=8.00e+00, error=2.96e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6010, objective=2.76e-01, stepsize=8.00e+00, error=2.94e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6020, objective=2.76e-01, stepsize=8.00e+00, error=2.93e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6030, objective=2.76e-01, stepsize=8.00e+00, error=2.91e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6040, objective=2.76e-01, stepsize=8.00e+00, error=2.90e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6050, objective=2.76e-01, stepsize=1.60e+01, error=1.44e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6060, objective=2.76e-01, stepsize=4.00e+00, error=5.73e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6070, objective=2.76e-01, stepsize=8.00e+00, error=2.85e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6080, objective=2.76e-01, stepsize=8.00e+00, error=2.83e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6090, objective=2.76e-01, stepsize=8.00e+00, error=2.82e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6100, objective=2.76e-01, stepsize=8.00e+00, error=2.80e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6110, objective=2.76e-01, stepsize=8.00e+00, error=2.79e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6120, objective=2.76e-01, stepsize=8.00e+00, error=2.77e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6130, objective=2.76e-01, stepsize=1.60e+01, error=1.38e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6140, objective=2.76e-01, stepsize=4.00e+00, error=5.49e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6150, objective=2.76e-01, stepsize=8.00e+00, error=2.73e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6160, objective=2.76e-01, stepsize=8.00e+00, error=2.72e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6170, objective=2.76e-01, stepsize=8.00e+00, error=2.70e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6180, objective=2.76e-01, stepsize=8.00e+00, error=2.69e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6190, objective=2.76e-01, stepsize=8.00e+00, error=2.68e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6200, objective=2.76e-01, stepsize=8.00e+00, error=2.67e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6210, objective=2.76e-01, stepsize=8.00e+00, error=2.65e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6220, objective=2.76e-01, stepsize=1.60e+01, error=1.32e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6230, objective=2.76e-01, stepsize=4.00e+00, error=5.27e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6240, objective=2.76e-01, stepsize=8.00e+00, error=2.62e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6250, objective=2.76e-01, stepsize=8.00e+00, error=2.61e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6260, objective=2.76e-01, stepsize=8.00e+00, error=2.61e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6270, objective=2.76e-01, stepsize=8.00e+00, error=2.60e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6280, objective=2.76e-01, stepsize=8.00e+00, error=2.59e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6290, objective=2.76e-01, stepsize=8.00e+00, error=2.58e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6300, objective=2.76e-01, stepsize=8.00e+00, error=2.57e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6310, objective=2.76e-01, stepsize=1.60e+01, error=1.28e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6320, objective=2.76e-01, stepsize=4.00e+00, error=5.12e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6330, objective=2.76e-01, stepsize=8.00e+00, error=2.55e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6340, objective=2.76e-01, stepsize=8.00e+00, error=2.55e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6350, objective=2.76e-01, stepsize=8.00e+00, error=2.54e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6360, objective=2.76e-01, stepsize=8.00e+00, error=2.54e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6370, objective=2.76e-01, stepsize=8.00e+00, error=2.53e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6380, objective=2.76e-01, stepsize=8.00e+00, error=2.53e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6390, objective=2.76e-01, stepsize=8.00e+00, error=2.52e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6400, objective=2.76e-01, stepsize=8.00e+00, error=2.51e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6410, objective=2.76e-01, stepsize=1.60e+01, error=1.25e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6420, objective=2.76e-01, stepsize=4.00e+00, error=5.00e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6430, objective=2.76e-01, stepsize=8.00e+00, error=2.50e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6440, objective=2.76e-01, stepsize=8.00e+00, error=2.49e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6450, objective=2.76e-01, stepsize=8.00e+00, error=2.48e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6460, objective=2.76e-01, stepsize=8.00e+00, error=2.48e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6470, objective=2.76e-01, stepsize=8.00e+00, error=2.47e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6480, objective=2.76e-01, stepsize=8.00e+00, error=2.46e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6490, objective=2.76e-01, stepsize=8.00e+00, error=2.45e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6500, objective=2.76e-01, stepsize=8.00e+00, error=2.45e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6510, objective=2.76e-01, stepsize=1.60e+01, error=1.22e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6520, objective=2.76e-01, stepsize=4.00e+00, error=4.86e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6530, objective=2.76e-01, stepsize=8.00e+00, error=2.42e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6540, objective=2.76e-01, stepsize=8.00e+00, error=2.41e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6550, objective=2.76e-01, stepsize=8.00e+00, error=2.40e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6560, objective=2.76e-01, stepsize=8.00e+00, error=2.39e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6570, objective=2.76e-01, stepsize=8.00e+00, error=2.38e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6580, objective=2.76e-01, stepsize=8.00e+00, error=2.37e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6590, objective=2.76e-01, stepsize=1.60e+01, error=1.18e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6600, objective=2.76e-01, stepsize=4.00e+00, error=4.71e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6610, objective=2.76e-01, stepsize=8.00e+00, error=2.35e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6620, objective=2.76e-01, stepsize=8.00e+00, error=2.34e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6630, objective=2.76e-01, stepsize=8.00e+00, error=2.33e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6640, objective=2.76e-01, stepsize=8.00e+00, error=2.32e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6650, objective=2.76e-01, stepsize=8.00e+00, error=2.32e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6660, objective=2.76e-01, stepsize=8.00e+00, error=2.31e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6670, objective=2.76e-01, stepsize=8.00e+00, error=2.30e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6680, objective=2.76e-01, stepsize=1.60e+01, error=1.15e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6690, objective=2.76e-01, stepsize=4.00e+00, error=4.58e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6700, objective=2.76e-01, stepsize=8.00e+00, error=2.29e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6710, objective=2.76e-01, stepsize=8.00e+00, error=2.28e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6720, objective=2.76e-01, stepsize=8.00e+00, error=2.28e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6730, objective=2.76e-01, stepsize=8.00e+00, error=2.28e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6740, objective=2.76e-01, stepsize=8.00e+00, error=2.28e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6750, objective=2.76e-01, stepsize=8.00e+00, error=2.28e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6760, objective=2.76e-01, stepsize=1.60e+01, error=1.14e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6770, objective=2.76e-01, stepsize=4.00e+00, error=4.55e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6780, objective=2.76e-01, stepsize=8.00e+00, error=2.28e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6790, objective=2.76e-01, stepsize=8.00e+00, error=2.28e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6800, objective=2.76e-01, stepsize=8.00e+00, error=2.28e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6810, objective=2.76e-01, stepsize=8.00e+00, error=2.28e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6820, objective=2.76e-01, stepsize=8.00e+00, error=2.29e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6830, objective=2.76e-01, stepsize=8.00e+00, error=2.29e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6840, objective=2.76e-01, stepsize=8.00e+00, error=2.29e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6850, objective=2.76e-01, stepsize=8.00e+00, error=2.30e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6860, objective=2.76e-01, stepsize=1.60e+01, error=1.15e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6870, objective=2.76e-01, stepsize=4.00e+00, error=4.60e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6880, objective=2.76e-01, stepsize=8.00e+00, error=2.30e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6890, objective=2.76e-01, stepsize=8.00e+00, error=2.30e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6900, objective=2.76e-01, stepsize=8.00e+00, error=2.31e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6910, objective=2.76e-01, stepsize=8.00e+00, error=2.31e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6920, objective=2.76e-01, stepsize=8.00e+00, error=2.31e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6930, objective=2.76e-01, stepsize=8.00e+00, error=2.31e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6940, objective=2.76e-01, stepsize=8.00e+00, error=2.31e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6950, objective=2.76e-01, stepsize=1.60e+01, error=1.15e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6960, objective=2.76e-01, stepsize=4.00e+00, error=4.61e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6970, objective=2.76e-01, stepsize=8.00e+00, error=2.30e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6980, objective=2.76e-01, stepsize=8.00e+00, error=2.30e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 6990, objective=2.76e-01, stepsize=8.00e+00, error=2.29e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7000, objective=2.76e-01, stepsize=8.00e+00, error=2.29e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7010, objective=2.76e-01, stepsize=8.00e+00, error=2.28e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7020, objective=2.76e-01, stepsize=8.00e+00, error=2.27e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7030, objective=2.76e-01, stepsize=8.00e+00, error=2.27e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7040, objective=2.76e-01, stepsize=4.00e+00, error=4.52e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7050, objective=2.76e-01, stepsize=8.00e+00, error=2.25e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7060, objective=2.76e-01, stepsize=8.00e+00, error=2.24e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7070, objective=2.76e-01, stepsize=8.00e+00, error=2.23e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7080, objective=2.76e-01, stepsize=8.00e+00, error=2.22e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7090, objective=2.76e-01, stepsize=8.00e+00, error=2.21e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7100, objective=2.76e-01, stepsize=8.00e+00, error=2.20e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7110, objective=2.76e-01, stepsize=8.00e+00, error=2.19e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7120, objective=2.76e-01, stepsize=4.00e+00, error=4.36e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7130, objective=2.76e-01, stepsize=8.00e+00, error=2.17e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7140, objective=2.76e-01, stepsize=8.00e+00, error=2.16e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7150, objective=2.76e-01, stepsize=8.00e+00, error=2.14e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7160, objective=2.76e-01, stepsize=8.00e+00, error=2.13e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7170, objective=2.76e-01, stepsize=8.00e+00, error=2.12e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7180, objective=2.76e-01, stepsize=8.00e+00, error=2.11e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7190, objective=2.76e-01, stepsize=8.00e+00, error=2.10e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7200, objective=2.76e-01, stepsize=4.00e+00, error=4.17e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7210, objective=2.76e-01, stepsize=8.00e+00, error=2.07e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7220, objective=2.76e-01, stepsize=8.00e+00, error=2.06e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7230, objective=2.76e-01, stepsize=8.00e+00, error=2.05e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7240, objective=2.76e-01, stepsize=8.00e+00, error=2.04e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7250, objective=2.76e-01, stepsize=8.00e+00, error=2.03e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7260, objective=2.76e-01, stepsize=8.00e+00, error=2.02e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7270, objective=2.76e-01, stepsize=8.00e+00, error=2.01e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7280, objective=2.76e-01, stepsize=4.00e+00, error=4.01e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7290, objective=2.76e-01, stepsize=8.00e+00, error=2.00e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7300, objective=2.76e-01, stepsize=8.00e+00, error=1.99e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7310, objective=2.76e-01, stepsize=8.00e+00, error=1.98e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7320, objective=2.76e-01, stepsize=8.00e+00, error=1.97e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7330, objective=2.76e-01, stepsize=8.00e+00, error=1.97e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7340, objective=2.76e-01, stepsize=8.00e+00, error=1.96e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7350, objective=2.76e-01, stepsize=8.00e+00, error=1.95e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7360, objective=2.76e-01, stepsize=1.60e+01, error=9.72e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7370, objective=2.76e-01, stepsize=4.00e+00, error=3.88e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7380, objective=2.76e-01, stepsize=8.00e+00, error=1.93e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7390, objective=2.76e-01, stepsize=8.00e+00, error=1.93e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7400, objective=2.76e-01, stepsize=8.00e+00, error=1.92e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7410, objective=2.76e-01, stepsize=8.00e+00, error=1.92e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7420, objective=2.76e-01, stepsize=8.00e+00, error=1.91e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7430, objective=2.76e-01, stepsize=8.00e+00, error=1.91e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7440, objective=2.76e-01, stepsize=8.00e+00, error=1.90e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7450, objective=2.76e-01, stepsize=1.60e+01, error=9.47e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7460, objective=2.76e-01, stepsize=4.00e+00, error=3.78e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7470, objective=2.76e-01, stepsize=8.00e+00, error=1.88e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7480, objective=2.76e-01, stepsize=8.00e+00, error=1.88e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7490, objective=2.76e-01, stepsize=8.00e+00, error=1.87e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7500, objective=2.76e-01, stepsize=8.00e+00, error=1.87e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7510, objective=2.76e-01, stepsize=8.00e+00, error=1.86e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7520, objective=2.76e-01, stepsize=8.00e+00, error=1.86e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7530, objective=2.76e-01, stepsize=8.00e+00, error=1.85e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7540, objective=2.76e-01, stepsize=4.00e+00, error=3.69e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7550, objective=2.76e-01, stepsize=8.00e+00, error=1.84e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7560, objective=2.76e-01, stepsize=1.60e+01, error=9.16e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7570, objective=2.76e-01, stepsize=4.00e+00, error=3.65e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7580, objective=2.76e-01, stepsize=8.00e+00, error=1.82e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7590, objective=2.76e-01, stepsize=8.00e+00, error=1.81e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7600, objective=2.76e-01, stepsize=8.00e+00, error=1.81e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7610, objective=2.76e-01, stepsize=8.00e+00, error=1.80e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7620, objective=2.76e-01, stepsize=8.00e+00, error=1.79e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7630, objective=2.76e-01, stepsize=8.00e+00, error=1.78e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7640, objective=2.76e-01, stepsize=8.00e+00, error=1.78e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7650, objective=2.76e-01, stepsize=1.60e+01, error=8.85e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7660, objective=2.76e-01, stepsize=4.00e+00, error=3.53e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7670, objective=2.76e-01, stepsize=8.00e+00, error=1.76e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7680, objective=2.76e-01, stepsize=8.00e+00, error=1.75e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7690, objective=2.76e-01, stepsize=8.00e+00, error=1.74e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7700, objective=2.76e-01, stepsize=8.00e+00, error=1.74e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7710, objective=2.76e-01, stepsize=8.00e+00, error=1.73e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7720, objective=2.76e-01, stepsize=8.00e+00, error=1.73e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7730, objective=2.76e-01, stepsize=8.00e+00, error=1.72e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7740, objective=2.76e-01, stepsize=1.60e+01, error=8.58e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7750, objective=2.76e-01, stepsize=4.00e+00, error=3.42e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7760, objective=2.76e-01, stepsize=8.00e+00, error=1.71e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7770, objective=2.76e-01, stepsize=8.00e+00, error=1.70e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7780, objective=2.76e-01, stepsize=8.00e+00, error=1.70e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7790, objective=2.76e-01, stepsize=8.00e+00, error=1.70e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7800, objective=2.76e-01, stepsize=8.00e+00, error=1.69e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7810, objective=2.76e-01, stepsize=8.00e+00, error=1.69e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7820, objective=2.76e-01, stepsize=8.00e+00, error=1.69e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7830, objective=2.76e-01, stepsize=1.60e+01, error=8.45e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7840, objective=2.76e-01, stepsize=4.00e+00, error=3.38e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7850, objective=2.76e-01, stepsize=8.00e+00, error=1.69e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7860, objective=2.76e-01, stepsize=8.00e+00, error=1.69e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7870, objective=2.76e-01, stepsize=8.00e+00, error=1.69e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7880, objective=2.76e-01, stepsize=8.00e+00, error=1.69e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7890, objective=2.76e-01, stepsize=8.00e+00, error=1.69e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7900, objective=2.76e-01, stepsize=8.00e+00, error=1.69e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7910, objective=2.76e-01, stepsize=8.00e+00, error=1.69e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7920, objective=2.76e-01, stepsize=8.00e+00, error=1.69e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7930, objective=2.76e-01, stepsize=1.60e+01, error=8.48e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7940, objective=2.76e-01, stepsize=4.00e+00, error=3.39e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7950, objective=2.76e-01, stepsize=8.00e+00, error=1.70e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7960, objective=2.76e-01, stepsize=8.00e+00, error=1.70e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7970, objective=2.76e-01, stepsize=8.00e+00, error=1.70e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7980, objective=2.76e-01, stepsize=8.00e+00, error=1.70e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 7990, objective=2.76e-01, stepsize=8.00e+00, error=1.70e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8000, objective=2.76e-01, stepsize=8.00e+00, error=1.70e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8010, objective=2.76e-01, stepsize=8.00e+00, error=1.70e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8020, objective=2.76e-01, stepsize=1.60e+01, error=8.52e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8030, objective=2.76e-01, stepsize=4.00e+00, error=3.41e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8040, objective=2.76e-01, stepsize=8.00e+00, error=1.70e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8050, objective=2.76e-01, stepsize=8.00e+00, error=1.70e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8060, objective=2.76e-01, stepsize=8.00e+00, error=1.70e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8070, objective=2.76e-01, stepsize=8.00e+00, error=1.70e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8080, objective=2.76e-01, stepsize=8.00e+00, error=1.70e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8090, objective=2.76e-01, stepsize=8.00e+00, error=1.69e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8100, objective=2.76e-01, stepsize=8.00e+00, error=1.69e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8110, objective=2.76e-01, stepsize=1.60e+01, error=8.42e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8120, objective=2.76e-01, stepsize=4.00e+00, error=3.36e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8130, objective=2.76e-01, stepsize=1.60e+01, error=8.37e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8140, objective=2.76e-01, stepsize=8.00e+00, error=1.67e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8150, objective=2.76e-01, stepsize=4.00e+00, error=3.33e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8160, objective=2.76e-01, stepsize=8.00e+00, error=1.66e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8170, objective=2.76e-01, stepsize=8.00e+00, error=1.65e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8180, objective=2.76e-01, stepsize=8.00e+00, error=1.64e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8190, objective=2.76e-01, stepsize=8.00e+00, error=1.63e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8200, objective=2.76e-01, stepsize=8.00e+00, error=1.63e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8210, objective=2.76e-01, stepsize=4.00e+00, error=3.24e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8220, objective=2.76e-01, stepsize=1.60e+01, error=8.03e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8230, objective=2.76e-01, stepsize=8.00e+00, error=1.60e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8240, objective=2.76e-01, stepsize=4.00e+00, error=3.18e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8250, objective=2.76e-01, stepsize=8.00e+00, error=1.58e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8260, objective=2.76e-01, stepsize=4.00e+00, error=3.14e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8270, objective=2.76e-01, stepsize=8.00e+00, error=1.56e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8280, objective=2.76e-01, stepsize=8.00e+00, error=1.55e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8290, objective=2.76e-01, stepsize=8.00e+00, error=1.54e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8300, objective=2.76e-01, stepsize=8.00e+00, error=1.53e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8310, objective=2.76e-01, stepsize=8.00e+00, error=1.52e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8320, objective=2.76e-01, stepsize=4.00e+00, error=3.03e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8330, objective=2.76e-01, stepsize=1.60e+01, error=7.51e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8340, objective=2.76e-01, stepsize=4.00e+00, error=2.99e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8350, objective=2.76e-01, stepsize=1.60e+01, error=7.43e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8360, objective=2.76e-01, stepsize=8.00e+00, error=1.48e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8370, objective=2.76e-01, stepsize=4.00e+00, error=2.94e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8380, objective=2.76e-01, stepsize=8.00e+00, error=1.46e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8390, objective=2.76e-01, stepsize=4.00e+00, error=2.91e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8400, objective=2.76e-01, stepsize=8.00e+00, error=1.45e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8410, objective=2.76e-01, stepsize=4.00e+00, error=2.89e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8420, objective=2.76e-01, stepsize=8.00e+00, error=1.44e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8430, objective=2.76e-01, stepsize=4.00e+00, error=2.87e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8440, objective=2.76e-01, stepsize=8.00e+00, error=1.43e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8450, objective=2.76e-01, stepsize=4.00e+00, error=2.85e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8460, objective=2.76e-01, stepsize=8.00e+00, error=1.42e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8470, objective=2.76e-01, stepsize=4.00e+00, error=2.83e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8480, objective=2.76e-01, stepsize=8.00e+00, error=1.41e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8490, objective=2.76e-01, stepsize=4.00e+00, error=2.81e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8500, objective=2.76e-01, stepsize=8.00e+00, error=1.40e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8510, objective=2.76e-01, stepsize=8.00e+00, error=1.40e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8520, objective=2.76e-01, stepsize=8.00e+00, error=1.40e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8530, objective=2.76e-01, stepsize=8.00e+00, error=1.39e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8540, objective=2.76e-01, stepsize=8.00e+00, error=1.39e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8550, objective=2.76e-01, stepsize=8.00e+00, error=1.39e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8560, objective=2.76e-01, stepsize=8.00e+00, error=1.38e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8570, objective=2.76e-01, stepsize=8.00e+00, error=1.38e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8580, objective=2.76e-01, stepsize=8.00e+00, error=1.38e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8590, objective=2.76e-01, stepsize=8.00e+00, error=1.37e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8600, objective=2.76e-01, stepsize=8.00e+00, error=1.37e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8610, objective=2.76e-01, stepsize=8.00e+00, error=1.37e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8620, objective=2.76e-01, stepsize=8.00e+00, error=1.36e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8630, objective=2.76e-01, stepsize=8.00e+00, error=1.36e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8640, objective=2.76e-01, stepsize=8.00e+00, error=1.35e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8650, objective=2.76e-01, stepsize=8.00e+00, error=1.35e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8660, objective=2.76e-01, stepsize=8.00e+00, error=1.34e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8670, objective=2.76e-01, stepsize=8.00e+00, error=1.34e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8680, objective=2.76e-01, stepsize=8.00e+00, error=1.33e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8690, objective=2.76e-01, stepsize=8.00e+00, error=1.33e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8700, objective=2.76e-01, stepsize=8.00e+00, error=1.32e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8710, objective=2.76e-01, stepsize=8.00e+00, error=1.32e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8720, objective=2.76e-01, stepsize=8.00e+00, error=1.31e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8730, objective=2.76e-01, stepsize=8.00e+00, error=1.30e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8740, objective=2.76e-01, stepsize=8.00e+00, error=1.30e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8750, objective=2.76e-01, stepsize=8.00e+00, error=1.29e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8760, objective=2.76e-01, stepsize=8.00e+00, error=1.29e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8770, objective=2.76e-01, stepsize=8.00e+00, error=1.28e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8780, objective=2.76e-01, stepsize=8.00e+00, error=1.28e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8790, objective=2.76e-01, stepsize=4.00e+00, error=2.54e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8800, objective=2.76e-01, stepsize=8.00e+00, error=1.26e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8810, objective=2.76e-01, stepsize=4.00e+00, error=2.52e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8820, objective=2.76e-01, stepsize=1.60e+01, error=6.27e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8830, objective=2.76e-01, stepsize=4.00e+00, error=2.50e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8840, objective=2.76e-01, stepsize=1.60e+01, error=6.22e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8850, objective=2.76e-01, stepsize=4.00e+00, error=2.48e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8860, objective=2.76e-01, stepsize=1.60e+01, error=6.18e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8870, objective=2.76e-01, stepsize=4.00e+00, error=2.47e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8880, objective=2.76e-01, stepsize=1.60e+01, error=6.14e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8890, objective=2.76e-01, stepsize=8.00e+00, error=1.23e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8900, objective=2.76e-01, stepsize=4.00e+00, error=2.45e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8910, objective=2.76e-01, stepsize=8.00e+00, error=1.22e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8920, objective=2.76e-01, stepsize=4.00e+00, error=2.43e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8930, objective=2.76e-01, stepsize=8.00e+00, error=1.22e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8940, objective=2.76e-01, stepsize=4.00e+00, error=2.43e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8950, objective=2.76e-01, stepsize=8.00e+00, error=1.21e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8960, objective=2.76e-01, stepsize=4.00e+00, error=2.42e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8970, objective=2.76e-01, stepsize=8.00e+00, error=1.21e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8980, objective=2.76e-01, stepsize=8.00e+00, error=1.21e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 8990, objective=2.76e-01, stepsize=8.00e+00, error=1.21e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9000, objective=2.76e-01, stepsize=8.00e+00, error=1.21e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9010, objective=2.76e-01, stepsize=8.00e+00, error=1.21e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9020, objective=2.76e-01, stepsize=8.00e+00, error=1.20e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9030, objective=2.76e-01, stepsize=8.00e+00, error=1.20e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9040, objective=2.76e-01, stepsize=8.00e+00, error=1.20e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9050, objective=2.76e-01, stepsize=8.00e+00, error=1.20e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9060, objective=2.76e-01, stepsize=4.00e+00, error=2.41e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9070, objective=2.76e-01, stepsize=8.00e+00, error=1.20e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9080, objective=2.76e-01, stepsize=4.00e+00, error=2.41e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9090, objective=2.76e-01, stepsize=1.60e+01, error=6.01e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9100, objective=2.76e-01, stepsize=4.00e+00, error=2.40e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9110, objective=2.76e-01, stepsize=1.60e+01, error=6.00e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9120, objective=2.76e-01, stepsize=4.00e+00, error=2.40e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9130, objective=2.76e-01, stepsize=1.60e+01, error=5.99e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9140, objective=2.76e-01, stepsize=8.00e+00, error=1.20e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9150, objective=2.76e-01, stepsize=4.00e+00, error=2.39e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9160, objective=2.76e-01, stepsize=8.00e+00, error=1.20e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9170, objective=2.76e-01, stepsize=4.00e+00, error=2.39e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9180, objective=2.76e-01, stepsize=8.00e+00, error=1.19e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9190, objective=2.76e-01, stepsize=4.00e+00, error=2.38e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9200, objective=2.76e-01, stepsize=8.00e+00, error=1.19e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9210, objective=2.76e-01, stepsize=4.00e+00, error=2.37e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9220, objective=2.76e-01, stepsize=8.00e+00, error=1.18e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9230, objective=2.76e-01, stepsize=8.00e+00, error=1.18e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9240, objective=2.76e-01, stepsize=8.00e+00, error=1.17e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9250, objective=2.76e-01, stepsize=8.00e+00, error=1.17e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9260, objective=2.76e-01, stepsize=8.00e+00, error=1.16e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9270, objective=2.76e-01, stepsize=8.00e+00, error=1.16e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9280, objective=2.76e-01, stepsize=8.00e+00, error=1.15e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9290, objective=2.76e-01, stepsize=4.00e+00, error=2.29e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9300, objective=2.76e-01, stepsize=1.60e+01, error=5.69e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9310, objective=2.76e-01, stepsize=4.00e+00, error=2.27e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9320, objective=2.76e-01, stepsize=1.60e+01, error=5.62e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9330, objective=2.76e-01, stepsize=8.00e+00, error=1.12e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9340, objective=2.76e-01, stepsize=4.00e+00, error=2.22e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9350, objective=2.76e-01, stepsize=8.00e+00, error=1.11e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9360, objective=2.76e-01, stepsize=4.00e+00, error=2.19e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9370, objective=2.76e-01, stepsize=8.00e+00, error=1.09e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9380, objective=2.76e-01, stepsize=4.00e+00, error=2.17e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9390, objective=2.76e-01, stepsize=8.00e+00, error=1.08e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9400, objective=2.76e-01, stepsize=8.00e+00, error=1.07e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9410, objective=2.76e-01, stepsize=8.00e+00, error=1.06e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9420, objective=2.76e-01, stepsize=8.00e+00, error=1.06e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9430, objective=2.76e-01, stepsize=8.00e+00, error=1.05e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9440, objective=2.76e-01, stepsize=8.00e+00, error=1.04e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9450, objective=2.76e-01, stepsize=8.00e+00, error=1.04e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9460, objective=2.76e-01, stepsize=4.00e+00, error=2.07e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9470, objective=2.76e-01, stepsize=1.60e+01, error=5.13e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9480, objective=2.76e-01, stepsize=4.00e+00, error=2.05e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9490, objective=2.76e-01, stepsize=1.60e+01, error=5.09e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9500, objective=2.76e-01, stepsize=4.00e+00, error=2.03e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9510, objective=2.76e-01, stepsize=1.60e+01, error=5.06e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9520, objective=2.76e-01, stepsize=8.00e+00, error=1.01e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9530, objective=2.76e-01, stepsize=4.00e+00, error=2.01e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9540, objective=2.76e-01, stepsize=8.00e+00, error=1.00e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9550, objective=2.76e-01, stepsize=4.00e+00, error=2.00e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9560, objective=2.76e-01, stepsize=8.00e+00, error=1.00e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9570, objective=2.76e-01, stepsize=4.00e+00, error=2.00e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9580, objective=2.76e-01, stepsize=8.00e+00, error=1.00e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9590, objective=2.76e-01, stepsize=4.00e+00, error=2.00e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9600, objective=2.76e-01, stepsize=8.00e+00, error=9.99e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9610, objective=2.76e-01, stepsize=4.00e+00, error=2.00e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9620, objective=2.76e-01, stepsize=8.00e+00, error=9.99e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9630, objective=2.76e-01, stepsize=4.00e+00, error=2.00e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9640, objective=2.76e-01, stepsize=8.00e+00, error=1.00e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9650, objective=2.76e-01, stepsize=4.00e+00, error=2.00e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9660, objective=2.76e-01, stepsize=8.00e+00, error=1.00e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9670, objective=2.76e-01, stepsize=4.00e+00, error=2.00e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9680, objective=2.76e-01, stepsize=8.00e+00, error=1.00e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9690, objective=2.76e-01, stepsize=4.00e+00, error=2.01e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9700, objective=2.76e-01, stepsize=8.00e+00, error=1.00e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9710, objective=2.76e-01, stepsize=4.00e+00, error=2.00e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9720, objective=2.76e-01, stepsize=8.00e+00, error=1.00e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9730, objective=2.76e-01, stepsize=8.00e+00, error=1.00e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9740, objective=2.76e-01, stepsize=8.00e+00, error=1.00e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9750, objective=2.76e-01, stepsize=8.00e+00, error=9.99e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9760, objective=2.76e-01, stepsize=8.00e+00, error=9.98e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9770, objective=2.76e-01, stepsize=8.00e+00, error=9.96e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9780, objective=2.76e-01, stepsize=8.00e+00, error=9.94e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9790, objective=2.76e-01, stepsize=8.00e+00, error=9.92e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9800, objective=2.76e-01, stepsize=8.00e+00, error=9.89e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9810, objective=2.76e-01, stepsize=8.00e+00, error=9.86e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9820, objective=2.76e-01, stepsize=8.00e+00, error=9.82e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9830, objective=2.76e-01, stepsize=4.00e+00, error=1.96e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9840, objective=2.76e-01, stepsize=8.00e+00, error=9.74e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9850, objective=2.76e-01, stepsize=4.00e+00, error=1.94e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9860, objective=2.76e-01, stepsize=1.60e+01, error=4.83e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9870, objective=2.76e-01, stepsize=4.00e+00, error=1.92e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9880, objective=2.76e-01, stepsize=1.60e+01, error=4.78e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9890, objective=2.76e-01, stepsize=4.00e+00, error=1.90e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9900, objective=2.76e-01, stepsize=1.60e+01, error=4.74e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9910, objective=2.76e-01, stepsize=8.00e+00, error=9.42e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9920, objective=2.76e-01, stepsize=4.00e+00, error=1.87e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9930, objective=2.76e-01, stepsize=8.00e+00, error=9.32e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9940, objective=2.76e-01, stepsize=4.00e+00, error=1.86e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9950, objective=2.76e-01, stepsize=8.00e+00, error=9.23e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9960, objective=2.76e-01, stepsize=4.00e+00, error=1.84e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9970, objective=2.76e-01, stepsize=8.00e+00, error=9.14e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9980, objective=2.76e-01, stepsize=4.00e+00, error=1.82e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 9990, objective=2.76e-01, stepsize=8.00e+00, error=9.05e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10000, objective=2.76e-01, stepsize=8.00e+00, error=9.02e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10010, objective=2.76e-01, stepsize=8.00e+00, error=8.98e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10020, objective=2.76e-01, stepsize=8.00e+00, error=8.95e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10030, objective=2.76e-01, stepsize=8.00e+00, error=8.92e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10040, objective=2.76e-01, stepsize=8.00e+00, error=8.89e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10050, objective=2.76e-01, stepsize=8.00e+00, error=8.87e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10060, objective=2.76e-01, stepsize=8.00e+00, error=8.85e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10070, objective=2.76e-01, stepsize=8.00e+00, error=8.83e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10080, objective=2.76e-01, stepsize=8.00e+00, error=8.82e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10090, objective=2.76e-01, stepsize=8.00e+00, error=8.80e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10100, objective=2.76e-01, stepsize=4.00e+00, error=1.76e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10110, objective=2.76e-01, stepsize=8.00e+00, error=8.79e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10120, objective=2.76e-01, stepsize=4.00e+00, error=1.76e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10130, objective=2.76e-01, stepsize=1.60e+01, error=4.39e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10140, objective=2.76e-01, stepsize=4.00e+00, error=1.75e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10150, objective=2.76e-01, stepsize=1.60e+01, error=4.39e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10160, objective=2.76e-01, stepsize=4.00e+00, error=1.75e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10170, objective=2.76e-01, stepsize=1.60e+01, error=4.39e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10180, objective=2.76e-01, stepsize=4.00e+00, error=1.76e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10190, objective=2.76e-01, stepsize=1.60e+01, error=4.39e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10200, objective=2.76e-01, stepsize=4.00e+00, error=1.76e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10210, objective=2.76e-01, stepsize=1.60e+01, error=4.39e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10220, objective=2.76e-01, stepsize=8.00e+00, error=8.78e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10230, objective=2.76e-01, stepsize=1.60e+01, error=4.39e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10240, objective=2.76e-01, stepsize=8.00e+00, error=8.78e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10250, objective=2.76e-01, stepsize=4.00e+00, error=1.75e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10260, objective=2.76e-01, stepsize=8.00e+00, error=8.77e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10270, objective=2.76e-01, stepsize=4.00e+00, error=1.75e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10280, objective=2.76e-01, stepsize=8.00e+00, error=8.76e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10290, objective=2.76e-01, stepsize=4.00e+00, error=1.75e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10300, objective=2.76e-01, stepsize=8.00e+00, error=8.74e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10310, objective=2.76e-01, stepsize=8.00e+00, error=8.72e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10320, objective=2.76e-01, stepsize=8.00e+00, error=8.71e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10330, objective=2.76e-01, stepsize=8.00e+00, error=8.69e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10340, objective=2.76e-01, stepsize=8.00e+00, error=8.67e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10350, objective=2.76e-01, stepsize=8.00e+00, error=8.65e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10360, objective=2.76e-01, stepsize=8.00e+00, error=8.63e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10370, objective=2.76e-01, stepsize=4.00e+00, error=1.72e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10380, objective=2.76e-01, stepsize=1.60e+01, error=4.28e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10390, objective=2.76e-01, stepsize=4.00e+00, error=1.71e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10400, objective=2.76e-01, stepsize=1.60e+01, error=4.25e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10410, objective=2.76e-01, stepsize=4.00e+00, error=1.70e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10420, objective=2.76e-01, stepsize=1.60e+01, error=4.22e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10430, objective=2.76e-01, stepsize=8.00e+00, error=8.42e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10440, objective=2.76e-01, stepsize=4.00e+00, error=1.68e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10450, objective=2.76e-01, stepsize=8.00e+00, error=8.35e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10460, objective=2.76e-01, stepsize=4.00e+00, error=1.66e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10470, objective=2.76e-01, stepsize=4.00e+00, error=1.66e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10480, objective=2.76e-01, stepsize=4.00e+00, error=1.65e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10490, objective=2.76e-01, stepsize=8.00e+00, error=8.21e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10500, objective=2.76e-01, stepsize=8.00e+00, error=8.19e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10510, objective=2.76e-01, stepsize=8.00e+00, error=8.15e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10520, objective=2.76e-01, stepsize=4.00e+00, error=1.62e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10530, objective=2.76e-01, stepsize=1.60e+01, error=4.05e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10540, objective=2.76e-01, stepsize=1.60e+01, error=4.03e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10550, objective=2.76e-01, stepsize=8.00e+00, error=8.05e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10560, objective=2.76e-01, stepsize=4.00e+00, error=1.60e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10570, objective=2.76e-01, stepsize=4.00e+00, error=1.60e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10580, objective=2.76e-01, stepsize=8.00e+00, error=7.99e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10590, objective=2.76e-01, stepsize=8.00e+00, error=7.97e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10600, objective=2.76e-01, stepsize=8.00e+00, error=7.96e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10610, objective=2.76e-01, stepsize=1.60e+01, error=3.98e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10620, objective=2.76e-01, stepsize=4.00e+00, error=1.59e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10630, objective=2.76e-01, stepsize=4.00e+00, error=1.59e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10640, objective=2.76e-01, stepsize=1.60e+01, error=3.97e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10650, objective=2.76e-01, stepsize=1.60e+01, error=3.98e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10660, objective=2.76e-01, stepsize=8.00e+00, error=7.96e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10670, objective=2.76e-01, stepsize=4.00e+00, error=1.59e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10680, objective=2.76e-01, stepsize=4.00e+00, error=1.60e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10690, objective=2.76e-01, stepsize=4.00e+00, error=1.60e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10700, objective=2.76e-01, stepsize=4.00e+00, error=1.60e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10710, objective=2.76e-01, stepsize=8.00e+00, error=8.03e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10720, objective=2.76e-01, stepsize=1.60e+01, error=4.03e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10730, objective=2.76e-01, stepsize=8.00e+00, error=8.07e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10740, objective=2.76e-01, stepsize=4.00e+00, error=1.62e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10750, objective=2.76e-01, stepsize=4.00e+00, error=1.63e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10760, objective=2.76e-01, stepsize=1.60e+01, error=4.08e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10770, objective=2.76e-01, stepsize=4.00e+00, error=1.63e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10780, objective=2.76e-01, stepsize=4.00e+00, error=1.64e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10790, objective=2.76e-01, stepsize=1.60e+01, error=4.12e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10800, objective=2.76e-01, stepsize=1.60e+01, error=4.13e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10810, objective=2.76e-01, stepsize=8.00e+00, error=8.28e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10820, objective=2.76e-01, stepsize=8.00e+00, error=8.31e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10830, objective=2.76e-01, stepsize=4.00e+00, error=1.67e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10840, objective=2.76e-01, stepsize=8.00e+00, error=8.34e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10850, objective=2.76e-01, stepsize=8.00e+00, error=8.37e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10860, objective=2.76e-01, stepsize=4.00e+00, error=1.68e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10870, objective=2.76e-01, stepsize=4.00e+00, error=1.68e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10880, objective=2.76e-01, stepsize=4.00e+00, error=1.68e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10890, objective=2.76e-01, stepsize=4.00e+00, error=1.68e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10900, objective=2.76e-01, stepsize=8.00e+00, error=8.44e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10910, objective=2.76e-01, stepsize=1.60e+01, error=4.23e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10920, objective=2.76e-01, stepsize=8.00e+00, error=8.44e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10930, objective=2.76e-01, stepsize=8.00e+00, error=8.44e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10940, objective=2.76e-01, stepsize=8.00e+00, error=8.44e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10950, objective=2.76e-01, stepsize=8.00e+00, error=8.43e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10960, objective=2.76e-01, stepsize=8.00e+00, error=8.42e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10970, objective=2.76e-01, stepsize=4.00e+00, error=1.68e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10980, objective=2.76e-01, stepsize=1.60e+01, error=4.20e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 10990, objective=2.76e-01, stepsize=1.60e+01, error=4.20e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11000, objective=2.76e-01, stepsize=8.00e+00, error=8.36e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11010, objective=2.76e-01, stepsize=8.00e+00, error=8.35e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11020, objective=2.76e-01, stepsize=4.00e+00, error=1.67e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11030, objective=2.76e-01, stepsize=4.00e+00, error=1.66e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11040, objective=2.76e-01, stepsize=4.00e+00, error=1.65e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11050, objective=2.76e-01, stepsize=8.00e+00, error=8.25e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11060, objective=2.76e-01, stepsize=8.00e+00, error=8.21e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11070, objective=2.76e-01, stepsize=8.00e+00, error=8.18e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11080, objective=2.76e-01, stepsize=4.00e+00, error=1.63e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11090, objective=2.76e-01, stepsize=1.60e+01, error=4.07e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11100, objective=2.76e-01, stepsize=1.60e+01, error=4.05e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11110, objective=2.76e-01, stepsize=8.00e+00, error=8.07e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11120, objective=2.76e-01, stepsize=4.00e+00, error=1.61e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11130, objective=2.76e-01, stepsize=4.00e+00, error=1.60e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11140, objective=2.76e-01, stepsize=8.00e+00, error=7.98e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11150, objective=2.76e-01, stepsize=8.00e+00, error=7.97e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11160, objective=2.76e-01, stepsize=1.60e+01, error=3.97e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11170, objective=2.76e-01, stepsize=8.00e+00, error=7.91e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11180, objective=2.76e-01, stepsize=4.00e+00, error=1.58e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11190, objective=2.76e-01, stepsize=4.00e+00, error=1.58e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11200, objective=2.76e-01, stepsize=1.60e+01, error=3.93e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11210, objective=2.76e-01, stepsize=4.00e+00, error=1.57e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11220, objective=2.76e-01, stepsize=1.60e+01, error=3.92e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11230, objective=2.76e-01, stepsize=1.60e+01, error=3.91e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11240, objective=2.76e-01, stepsize=8.00e+00, error=7.81e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11250, objective=2.76e-01, stepsize=8.00e+00, error=7.81e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11260, objective=2.76e-01, stepsize=4.00e+00, error=1.56e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11270, objective=2.76e-01, stepsize=8.00e+00, error=7.79e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11280, objective=2.76e-01, stepsize=8.00e+00, error=7.79e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11290, objective=2.76e-01, stepsize=8.00e+00, error=7.79e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11300, objective=2.76e-01, stepsize=1.60e+01, error=3.90e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11310, objective=2.76e-01, stepsize=8.00e+00, error=7.79e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11320, objective=2.76e-01, stepsize=8.00e+00, error=7.79e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11330, objective=2.76e-01, stepsize=8.00e+00, error=7.79e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11340, objective=2.76e-01, stepsize=8.00e+00, error=7.79e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11350, objective=2.76e-01, stepsize=8.00e+00, error=7.79e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11360, objective=2.76e-01, stepsize=4.00e+00, error=1.56e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11370, objective=2.76e-01, stepsize=4.00e+00, error=1.56e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11380, objective=2.76e-01, stepsize=1.60e+01, error=3.90e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11390, objective=2.76e-01, stepsize=4.00e+00, error=1.56e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11400, objective=2.76e-01, stepsize=4.00e+00, error=1.56e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11410, objective=2.76e-01, stepsize=1.60e+01, error=3.90e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11420, objective=2.76e-01, stepsize=1.60e+01, error=3.90e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11430, objective=2.76e-01, stepsize=8.00e+00, error=7.79e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11440, objective=2.76e-01, stepsize=8.00e+00, error=7.79e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11450, objective=2.76e-01, stepsize=8.00e+00, error=7.79e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11460, objective=2.76e-01, stepsize=1.60e+01, error=3.89e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11470, objective=2.76e-01, stepsize=4.00e+00, error=1.56e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11480, objective=2.76e-01, stepsize=4.00e+00, error=1.55e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11490, objective=2.76e-01, stepsize=8.00e+00, error=7.77e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11500, objective=2.76e-01, stepsize=1.60e+01, error=3.88e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11510, objective=2.76e-01, stepsize=1.60e+01, error=3.88e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11520, objective=2.76e-01, stepsize=4.00e+00, error=1.55e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11530, objective=2.76e-01, stepsize=4.00e+00, error=1.55e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11540, objective=2.76e-01, stepsize=4.00e+00, error=1.55e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11550, objective=2.76e-01, stepsize=8.00e+00, error=7.72e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11560, objective=2.76e-01, stepsize=8.00e+00, error=7.71e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11570, objective=2.76e-01, stepsize=8.00e+00, error=7.70e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11580, objective=2.76e-01, stepsize=8.00e+00, error=7.69e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11590, objective=2.76e-01, stepsize=1.60e+01, error=3.84e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11600, objective=2.76e-01, stepsize=1.60e+01, error=3.83e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11610, objective=2.76e-01, stepsize=4.00e+00, error=1.53e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11620, objective=2.76e-01, stepsize=4.00e+00, error=1.53e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11630, objective=2.76e-01, stepsize=4.00e+00, error=1.53e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11640, objective=2.76e-01, stepsize=4.00e+00, error=1.53e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11650, objective=2.76e-01, stepsize=8.00e+00, error=7.63e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11660, objective=2.76e-01, stepsize=8.00e+00, error=7.62e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11670, objective=2.76e-01, stepsize=8.00e+00, error=7.62e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11680, objective=2.76e-01, stepsize=8.00e+00, error=7.62e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11690, objective=2.76e-01, stepsize=1.60e+01, error=3.81e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11700, objective=2.76e-01, stepsize=1.60e+01, error=3.81e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11710, objective=2.76e-01, stepsize=4.00e+00, error=1.52e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11720, objective=2.76e-01, stepsize=4.00e+00, error=1.52e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11730, objective=2.76e-01, stepsize=4.00e+00, error=1.52e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11740, objective=2.76e-01, stepsize=8.00e+00, error=7.62e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11750, objective=2.76e-01, stepsize=8.00e+00, error=7.63e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11760, objective=2.76e-01, stepsize=8.00e+00, error=7.64e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11770, objective=2.76e-01, stepsize=8.00e+00, error=7.65e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11780, objective=2.76e-01, stepsize=1.60e+01, error=3.83e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11790, objective=2.76e-01, stepsize=1.60e+01, error=3.84e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11800, objective=2.76e-01, stepsize=8.00e+00, error=7.70e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11810, objective=2.76e-01, stepsize=8.00e+00, error=7.72e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11820, objective=2.76e-01, stepsize=8.00e+00, error=7.74e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11830, objective=2.76e-01, stepsize=1.60e+01, error=3.88e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11840, objective=2.76e-01, stepsize=4.00e+00, error=1.55e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11850, objective=2.76e-01, stepsize=4.00e+00, error=1.56e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11860, objective=2.76e-01, stepsize=4.00e+00, error=1.56e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11870, objective=2.76e-01, stepsize=4.00e+00, error=1.57e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11880, objective=2.76e-01, stepsize=8.00e+00, error=7.87e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11890, objective=2.76e-01, stepsize=8.00e+00, error=7.90e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11900, objective=2.76e-01, stepsize=8.00e+00, error=7.93e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11910, objective=2.76e-01, stepsize=8.00e+00, error=7.96e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11920, objective=2.76e-01, stepsize=1.60e+01, error=3.99e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11930, objective=2.76e-01, stepsize=1.60e+01, error=4.01e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11940, objective=2.76e-01, stepsize=4.00e+00, error=1.60e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11950, objective=2.76e-01, stepsize=4.00e+00, error=1.61e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11960, objective=2.76e-01, stepsize=4.00e+00, error=1.62e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11970, objective=2.76e-01, stepsize=8.00e+00, error=8.09e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11980, objective=2.76e-01, stepsize=8.00e+00, error=8.11e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 11990, objective=2.76e-01, stepsize=8.00e+00, error=8.13e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12000, objective=2.76e-01, stepsize=8.00e+00, error=8.15e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12010, objective=2.76e-01, stepsize=1.60e+01, error=4.08e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12020, objective=2.76e-01, stepsize=1.60e+01, error=4.09e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12030, objective=2.76e-01, stepsize=4.00e+00, error=1.63e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12040, objective=2.76e-01, stepsize=4.00e+00, error=1.64e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12050, objective=2.76e-01, stepsize=4.00e+00, error=1.64e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12060, objective=2.76e-01, stepsize=4.00e+00, error=1.64e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12070, objective=2.76e-01, stepsize=8.00e+00, error=8.19e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12080, objective=2.76e-01, stepsize=8.00e+00, error=8.19e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12090, objective=2.76e-01, stepsize=8.00e+00, error=8.19e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12100, objective=2.76e-01, stepsize=1.60e+01, error=4.09e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12110, objective=2.76e-01, stepsize=1.60e+01, error=4.09e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12120, objective=2.76e-01, stepsize=4.00e+00, error=1.63e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12130, objective=2.76e-01, stepsize=4.00e+00, error=1.63e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12140, objective=2.76e-01, stepsize=4.00e+00, error=1.63e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12150, objective=2.76e-01, stepsize=4.00e+00, error=1.62e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12160, objective=2.76e-01, stepsize=8.00e+00, error=8.09e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12170, objective=2.76e-01, stepsize=8.00e+00, error=8.08e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12180, objective=2.76e-01, stepsize=8.00e+00, error=8.06e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12190, objective=2.76e-01, stepsize=8.00e+00, error=8.04e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12200, objective=2.76e-01, stepsize=1.60e+01, error=4.01e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12210, objective=2.76e-01, stepsize=4.00e+00, error=1.60e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12220, objective=2.76e-01, stepsize=4.00e+00, error=1.59e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12230, objective=2.76e-01, stepsize=4.00e+00, error=1.59e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12240, objective=2.76e-01, stepsize=4.00e+00, error=1.58e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12250, objective=2.76e-01, stepsize=8.00e+00, error=7.88e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12260, objective=2.76e-01, stepsize=8.00e+00, error=7.86e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12270, objective=2.76e-01, stepsize=8.00e+00, error=7.84e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12280, objective=2.76e-01, stepsize=8.00e+00, error=7.81e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12290, objective=2.76e-01, stepsize=1.60e+01, error=3.90e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12300, objective=2.76e-01, stepsize=1.60e+01, error=3.89e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12310, objective=2.76e-01, stepsize=4.00e+00, error=1.55e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12320, objective=2.76e-01, stepsize=4.00e+00, error=1.54e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12330, objective=2.76e-01, stepsize=4.00e+00, error=1.54e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12340, objective=2.76e-01, stepsize=4.00e+00, error=1.54e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12350, objective=2.76e-01, stepsize=8.00e+00, error=7.67e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12360, objective=2.76e-01, stepsize=8.00e+00, error=7.66e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12370, objective=2.76e-01, stepsize=8.00e+00, error=7.65e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12380, objective=2.76e-01, stepsize=8.00e+00, error=7.64e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12390, objective=2.76e-01, stepsize=1.60e+01, error=3.82e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12400, objective=2.76e-01, stepsize=4.00e+00, error=1.52e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12410, objective=2.76e-01, stepsize=4.00e+00, error=1.52e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12420, objective=2.76e-01, stepsize=4.00e+00, error=1.52e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12430, objective=2.76e-01, stepsize=4.00e+00, error=1.52e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12440, objective=2.76e-01, stepsize=8.00e+00, error=7.60e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12450, objective=2.76e-01, stepsize=8.00e+00, error=7.60e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12460, objective=2.76e-01, stepsize=8.00e+00, error=7.60e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12470, objective=2.76e-01, stepsize=8.00e+00, error=7.60e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12480, objective=2.76e-01, stepsize=1.60e+01, error=3.80e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12490, objective=2.76e-01, stepsize=1.60e+01, error=3.80e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12500, objective=2.76e-01, stepsize=4.00e+00, error=1.52e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12510, objective=2.76e-01, stepsize=4.00e+00, error=1.52e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12520, objective=2.76e-01, stepsize=4.00e+00, error=1.52e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12530, objective=2.76e-01, stepsize=8.00e+00, error=7.60e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12540, objective=2.76e-01, stepsize=8.00e+00, error=7.60e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12550, objective=2.76e-01, stepsize=4.00e+00, error=1.52e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12560, objective=2.76e-01, stepsize=8.00e+00, error=7.61e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12570, objective=2.76e-01, stepsize=1.60e+01, error=3.81e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12580, objective=2.76e-01, stepsize=1.60e+01, error=3.81e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12590, objective=2.76e-01, stepsize=4.00e+00, error=1.52e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12600, objective=2.76e-01, stepsize=4.00e+00, error=1.52e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12610, objective=2.76e-01, stepsize=8.00e+00, error=7.60e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12620, objective=2.76e-01, stepsize=4.00e+00, error=1.52e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12630, objective=2.76e-01, stepsize=8.00e+00, error=7.60e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12640, objective=2.76e-01, stepsize=4.00e+00, error=1.52e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12650, objective=2.76e-01, stepsize=8.00e+00, error=7.60e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12660, objective=2.76e-01, stepsize=1.60e+01, error=3.79e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12670, objective=2.76e-01, stepsize=1.60e+01, error=3.79e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12680, objective=2.76e-01, stepsize=4.00e+00, error=1.51e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12690, objective=2.76e-01, stepsize=4.00e+00, error=1.51e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12700, objective=2.76e-01, stepsize=4.00e+00, error=1.51e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12710, objective=2.76e-01, stepsize=8.00e+00, error=7.54e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12720, objective=2.76e-01, stepsize=8.00e+00, error=7.52e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12730, objective=2.76e-01, stepsize=8.00e+00, error=7.51e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12740, objective=2.76e-01, stepsize=8.00e+00, error=7.50e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12750, objective=2.76e-01, stepsize=1.60e+01, error=3.74e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12760, objective=2.76e-01, stepsize=1.60e+01, error=3.74e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12770, objective=2.76e-01, stepsize=4.00e+00, error=1.49e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12780, objective=2.76e-01, stepsize=4.00e+00, error=1.49e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12790, objective=2.76e-01, stepsize=4.00e+00, error=1.49e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12800, objective=2.76e-01, stepsize=4.00e+00, error=1.48e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12810, objective=2.76e-01, stepsize=8.00e+00, error=7.40e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12820, objective=2.76e-01, stepsize=8.00e+00, error=7.40e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12830, objective=2.76e-01, stepsize=8.00e+00, error=7.39e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12840, objective=2.76e-01, stepsize=8.00e+00, error=7.38e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12850, objective=2.76e-01, stepsize=1.60e+01, error=3.69e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12860, objective=2.76e-01, stepsize=4.00e+00, error=1.47e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12870, objective=2.76e-01, stepsize=4.00e+00, error=1.47e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12880, objective=2.76e-01, stepsize=4.00e+00, error=1.47e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12890, objective=2.76e-01, stepsize=4.00e+00, error=1.47e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12900, objective=2.76e-01, stepsize=8.00e+00, error=7.36e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12910, objective=2.76e-01, stepsize=8.00e+00, error=7.36e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12920, objective=2.76e-01, stepsize=8.00e+00, error=7.36e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12930, objective=2.76e-01, stepsize=8.00e+00, error=7.37e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12940, objective=2.76e-01, stepsize=4.00e+00, error=1.47e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12950, objective=2.76e-01, stepsize=1.60e+01, error=3.70e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12960, objective=2.76e-01, stepsize=4.00e+00, error=1.48e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12970, objective=2.76e-01, stepsize=4.00e+00, error=1.48e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12980, objective=2.76e-01, stepsize=4.00e+00, error=1.49e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 12990, objective=2.76e-01, stepsize=8.00e+00, error=7.43e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13000, objective=2.76e-01, stepsize=8.00e+00, error=7.45e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13010, objective=2.76e-01, stepsize=8.00e+00, error=7.46e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13020, objective=2.76e-01, stepsize=8.00e+00, error=7.48e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13030, objective=2.76e-01, stepsize=4.00e+00, error=1.50e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13040, objective=2.76e-01, stepsize=1.60e+01, error=3.76e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13050, objective=2.76e-01, stepsize=4.00e+00, error=1.51e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13060, objective=2.76e-01, stepsize=4.00e+00, error=1.51e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13070, objective=2.76e-01, stepsize=4.00e+00, error=1.51e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13080, objective=2.76e-01, stepsize=1.60e+01, error=3.79e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13090, objective=2.76e-01, stepsize=8.00e+00, error=7.60e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13100, objective=2.76e-01, stepsize=1.60e+01, error=3.81e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13110, objective=2.76e-01, stepsize=8.00e+00, error=7.64e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13120, objective=2.76e-01, stepsize=1.60e+01, error=3.83e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13130, objective=2.76e-01, stepsize=8.00e+00, error=7.64e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13140, objective=2.76e-01, stepsize=4.00e+00, error=1.53e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13150, objective=2.76e-01, stepsize=8.00e+00, error=7.67e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13160, objective=2.76e-01, stepsize=8.00e+00, error=7.67e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13170, objective=2.76e-01, stepsize=8.00e+00, error=7.67e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13180, objective=2.76e-01, stepsize=4.00e+00, error=1.53e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13190, objective=2.76e-01, stepsize=8.00e+00, error=7.68e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13200, objective=2.76e-01, stepsize=4.00e+00, error=1.53e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13210, objective=2.76e-01, stepsize=1.60e+01, error=3.84e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13220, objective=2.76e-01, stepsize=4.00e+00, error=1.53e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13230, objective=2.76e-01, stepsize=4.00e+00, error=1.53e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13240, objective=2.76e-01, stepsize=4.00e+00, error=1.53e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13250, objective=2.76e-01, stepsize=1.60e+01, error=3.82e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13260, objective=2.76e-01, stepsize=8.00e+00, error=7.62e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13270, objective=2.76e-01, stepsize=1.60e+01, error=3.81e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13280, objective=2.76e-01, stepsize=8.00e+00, error=7.59e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13290, objective=2.76e-01, stepsize=1.60e+01, error=3.79e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13300, objective=2.76e-01, stepsize=8.00e+00, error=7.53e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13310, objective=2.76e-01, stepsize=4.00e+00, error=1.50e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13320, objective=2.76e-01, stepsize=8.00e+00, error=7.49e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13330, objective=2.76e-01, stepsize=4.00e+00, error=1.50e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13340, objective=2.76e-01, stepsize=8.00e+00, error=7.44e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13350, objective=2.76e-01, stepsize=4.00e+00, error=1.48e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13360, objective=2.76e-01, stepsize=8.00e+00, error=7.40e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13370, objective=2.76e-01, stepsize=1.60e+01, error=3.68e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13380, objective=2.76e-01, stepsize=1.60e+01, error=3.66e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13390, objective=2.76e-01, stepsize=4.00e+00, error=1.45e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13400, objective=2.76e-01, stepsize=4.00e+00, error=1.45e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13410, objective=2.76e-01, stepsize=4.00e+00, error=1.44e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13420, objective=2.76e-01, stepsize=4.00e+00, error=1.43e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13430, objective=2.76e-01, stepsize=8.00e+00, error=7.11e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13440, objective=2.76e-01, stepsize=8.00e+00, error=7.07e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13450, objective=2.76e-01, stepsize=8.00e+00, error=7.04e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13460, objective=2.76e-01, stepsize=8.00e+00, error=7.01e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13470, objective=2.76e-01, stepsize=1.60e+01, error=3.49e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13480, objective=2.76e-01, stepsize=4.00e+00, error=1.39e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13490, objective=2.76e-01, stepsize=4.00e+00, error=1.38e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13500, objective=2.76e-01, stepsize=4.00e+00, error=1.37e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13510, objective=2.76e-01, stepsize=4.00e+00, error=1.37e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13520, objective=2.76e-01, stepsize=8.00e+00, error=6.81e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13530, objective=2.76e-01, stepsize=8.00e+00, error=6.79e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13540, objective=2.76e-01, stepsize=8.00e+00, error=6.77e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13550, objective=2.76e-01, stepsize=8.00e+00, error=6.75e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13560, objective=2.76e-01, stepsize=4.00e+00, error=1.35e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13570, objective=2.76e-01, stepsize=1.60e+01, error=3.36e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13580, objective=2.76e-01, stepsize=4.00e+00, error=1.34e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13590, objective=2.76e-01, stepsize=4.00e+00, error=1.34e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13600, objective=2.76e-01, stepsize=4.00e+00, error=1.34e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13610, objective=2.76e-01, stepsize=1.60e+01, error=3.34e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13620, objective=2.76e-01, stepsize=8.00e+00, error=6.68e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13630, objective=2.76e-01, stepsize=8.00e+00, error=6.67e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13640, objective=2.76e-01, stepsize=8.00e+00, error=6.66e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13650, objective=2.76e-01, stepsize=1.60e+01, error=3.33e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13660, objective=2.76e-01, stepsize=8.00e+00, error=6.64e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13670, objective=2.76e-01, stepsize=4.00e+00, error=1.33e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13680, objective=2.76e-01, stepsize=8.00e+00, error=6.64e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13690, objective=2.76e-01, stepsize=4.00e+00, error=1.33e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13700, objective=2.76e-01, stepsize=8.00e+00, error=6.63e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13710, objective=2.76e-01, stepsize=4.00e+00, error=1.32e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13720, objective=2.76e-01, stepsize=8.00e+00, error=6.62e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13730, objective=2.76e-01, stepsize=4.00e+00, error=1.32e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13740, objective=2.76e-01, stepsize=1.60e+01, error=3.30e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13750, objective=2.76e-01, stepsize=4.00e+00, error=1.32e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13760, objective=2.76e-01, stepsize=4.00e+00, error=1.32e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13770, objective=2.76e-01, stepsize=4.00e+00, error=1.31e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13780, objective=2.76e-01, stepsize=1.60e+01, error=3.28e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13790, objective=2.76e-01, stepsize=8.00e+00, error=6.54e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13800, objective=2.76e-01, stepsize=1.60e+01, error=3.26e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13810, objective=2.76e-01, stepsize=8.00e+00, error=6.51e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13820, objective=2.76e-01, stepsize=1.60e+01, error=3.25e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13830, objective=2.76e-01, stepsize=8.00e+00, error=6.46e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13840, objective=2.76e-01, stepsize=4.00e+00, error=1.29e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13850, objective=2.76e-01, stepsize=8.00e+00, error=6.43e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13860, objective=2.76e-01, stepsize=4.00e+00, error=1.28e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13870, objective=2.76e-01, stepsize=8.00e+00, error=6.39e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13880, objective=2.76e-01, stepsize=4.00e+00, error=1.27e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13890, objective=2.76e-01, stepsize=8.00e+00, error=6.35e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13900, objective=2.76e-01, stepsize=4.00e+00, error=1.26e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13910, objective=2.76e-01, stepsize=1.60e+01, error=3.16e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13920, objective=2.76e-01, stepsize=4.00e+00, error=1.26e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13930, objective=2.76e-01, stepsize=4.00e+00, error=1.25e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13940, objective=2.76e-01, stepsize=4.00e+00, error=1.25e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13950, objective=2.76e-01, stepsize=1.60e+01, error=3.12e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13960, objective=2.76e-01, stepsize=8.00e+00, error=6.21e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13970, objective=2.76e-01, stepsize=1.60e+01, error=3.10e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13980, objective=2.76e-01, stepsize=8.00e+00, error=6.19e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 13990, objective=2.76e-01, stepsize=1.60e+01, error=3.09e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14000, objective=2.76e-01, stepsize=8.00e+00, error=6.15e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14010, objective=2.76e-01, stepsize=4.00e+00, error=1.23e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14020, objective=2.76e-01, stepsize=8.00e+00, error=6.13e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14030, objective=2.76e-01, stepsize=4.00e+00, error=1.23e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14040, objective=2.76e-01, stepsize=8.00e+00, error=6.13e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14050, objective=2.76e-01, stepsize=4.00e+00, error=1.22e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14060, objective=2.76e-01, stepsize=8.00e+00, error=6.13e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14070, objective=2.76e-01, stepsize=4.00e+00, error=1.22e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14080, objective=2.76e-01, stepsize=1.60e+01, error=3.06e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14090, objective=2.76e-01, stepsize=4.00e+00, error=1.22e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14100, objective=2.76e-01, stepsize=4.00e+00, error=1.22e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14110, objective=2.76e-01, stepsize=4.00e+00, error=1.23e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14120, objective=2.76e-01, stepsize=1.60e+01, error=3.06e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14130, objective=2.76e-01, stepsize=8.00e+00, error=6.12e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14140, objective=2.76e-01, stepsize=1.60e+01, error=3.07e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14150, objective=2.76e-01, stepsize=8.00e+00, error=6.14e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14160, objective=2.76e-01, stepsize=1.60e+01, error=3.08e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14170, objective=2.76e-01, stepsize=8.00e+00, error=6.13e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14180, objective=2.76e-01, stepsize=4.00e+00, error=1.23e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14190, objective=2.76e-01, stepsize=8.00e+00, error=6.14e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14200, objective=2.76e-01, stepsize=4.00e+00, error=1.23e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14210, objective=2.76e-01, stepsize=8.00e+00, error=6.15e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14220, objective=2.76e-01, stepsize=4.00e+00, error=1.23e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14230, objective=2.76e-01, stepsize=8.00e+00, error=6.16e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14240, objective=2.76e-01, stepsize=4.00e+00, error=1.23e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14250, objective=2.76e-01, stepsize=8.00e+00, error=6.14e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14260, objective=2.76e-01, stepsize=4.00e+00, error=1.23e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14270, objective=2.76e-01, stepsize=4.00e+00, error=1.23e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14280, objective=2.76e-01, stepsize=4.00e+00, error=1.23e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14290, objective=2.76e-01, stepsize=8.00e+00, error=6.13e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14300, objective=2.76e-01, stepsize=8.00e+00, error=6.12e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14310, objective=2.76e-01, stepsize=1.60e+01, error=3.06e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14320, objective=2.76e-01, stepsize=4.00e+00, error=1.22e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14330, objective=2.76e-01, stepsize=1.60e+01, error=3.05e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14340, objective=2.76e-01, stepsize=8.00e+00, error=6.05e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14350, objective=2.76e-01, stepsize=4.00e+00, error=1.21e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14360, objective=2.76e-01, stepsize=8.00e+00, error=6.02e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14370, objective=2.76e-01, stepsize=4.00e+00, error=1.20e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14380, objective=2.76e-01, stepsize=8.00e+00, error=5.98e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14390, objective=2.76e-01, stepsize=4.00e+00, error=1.19e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14400, objective=2.76e-01, stepsize=8.00e+00, error=5.94e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14410, objective=2.76e-01, stepsize=4.00e+00, error=1.18e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14420, objective=2.76e-01, stepsize=1.60e+01, error=2.95e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14430, objective=2.76e-01, stepsize=4.00e+00, error=1.17e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14440, objective=2.76e-01, stepsize=4.00e+00, error=1.16e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14450, objective=2.76e-01, stepsize=4.00e+00, error=1.16e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14460, objective=2.76e-01, stepsize=1.60e+01, error=2.88e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14470, objective=2.76e-01, stepsize=8.00e+00, error=5.73e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14480, objective=2.76e-01, stepsize=1.60e+01, error=2.85e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14490, objective=2.76e-01, stepsize=8.00e+00, error=5.67e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14500, objective=2.76e-01, stepsize=1.60e+01, error=2.83e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14510, objective=2.76e-01, stepsize=8.00e+00, error=5.60e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14520, objective=2.76e-01, stepsize=4.00e+00, error=1.12e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14530, objective=2.76e-01, stepsize=8.00e+00, error=5.55e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14540, objective=2.76e-01, stepsize=4.00e+00, error=1.11e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14550, objective=2.76e-01, stepsize=8.00e+00, error=5.50e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14560, objective=2.76e-01, stepsize=4.00e+00, error=1.09e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14570, objective=2.76e-01, stepsize=8.00e+00, error=5.45e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14580, objective=2.76e-01, stepsize=4.00e+00, error=1.08e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14590, objective=2.76e-01, stepsize=1.60e+01, error=2.71e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14600, objective=2.76e-01, stepsize=4.00e+00, error=1.08e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14610, objective=2.76e-01, stepsize=4.00e+00, error=1.07e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14620, objective=2.76e-01, stepsize=4.00e+00, error=1.07e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14630, objective=2.76e-01, stepsize=1.60e+01, error=2.66e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14640, objective=2.76e-01, stepsize=8.00e+00, error=5.31e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14650, objective=2.76e-01, stepsize=1.60e+01, error=2.65e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14660, objective=2.76e-01, stepsize=8.00e+00, error=5.28e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14670, objective=2.76e-01, stepsize=1.60e+01, error=2.64e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14680, objective=2.76e-01, stepsize=8.00e+00, error=5.25e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14690, objective=2.76e-01, stepsize=4.00e+00, error=1.05e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14700, objective=2.76e-01, stepsize=8.00e+00, error=5.23e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14710, objective=2.76e-01, stepsize=4.00e+00, error=1.05e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14720, objective=2.76e-01, stepsize=8.00e+00, error=5.22e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14730, objective=2.76e-01, stepsize=4.00e+00, error=1.04e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14740, objective=2.76e-01, stepsize=8.00e+00, error=5.21e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14750, objective=2.76e-01, stepsize=4.00e+00, error=1.04e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14760, objective=2.76e-01, stepsize=1.60e+01, error=2.60e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14770, objective=2.76e-01, stepsize=4.00e+00, error=1.04e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14780, objective=2.76e-01, stepsize=4.00e+00, error=1.04e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14790, objective=2.76e-01, stepsize=4.00e+00, error=1.04e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14800, objective=2.76e-01, stepsize=1.60e+01, error=2.59e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14810, objective=2.76e-01, stepsize=4.00e+00, error=1.04e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14820, objective=2.76e-01, stepsize=8.00e+00, error=5.25e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14830, objective=2.76e-01, stepsize=4.00e+00, error=1.05e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14840, objective=2.76e-01, stepsize=1.60e+01, error=2.62e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14850, objective=2.76e-01, stepsize=4.00e+00, error=1.04e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14860, objective=2.76e-01, stepsize=4.00e+00, error=1.04e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14870, objective=2.76e-01, stepsize=4.00e+00, error=1.03e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14880, objective=2.76e-01, stepsize=4.00e+00, error=1.03e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14890, objective=2.76e-01, stepsize=8.00e+00, error=5.12e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14900, objective=2.76e-01, stepsize=4.00e+00, error=1.02e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14910, objective=2.76e-01, stepsize=8.00e+00, error=5.09e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14920, objective=2.76e-01, stepsize=4.00e+00, error=1.01e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14930, objective=2.76e-01, stepsize=1.60e+01, error=2.52e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14940, objective=2.76e-01, stepsize=4.00e+00, error=1.00e-03, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14950, objective=2.76e-01, stepsize=4.00e+00, error=9.99e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14960, objective=2.76e-01, stepsize=4.00e+00, error=9.95e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14970, objective=2.76e-01, stepsize=1.60e+01, error=2.47e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14980, objective=2.76e-01, stepsize=8.00e+00, error=4.92e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 14990, objective=2.76e-01, stepsize=1.60e+01, error=2.45e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15000, objective=2.76e-01, stepsize=8.00e+00, error=4.88e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15010, objective=2.76e-01, stepsize=1.60e+01, error=2.43e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15020, objective=2.76e-01, stepsize=8.00e+00, error=4.82e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15030, objective=2.76e-01, stepsize=4.00e+00, error=9.60e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15040, objective=2.76e-01, stepsize=8.00e+00, error=4.78e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15050, objective=2.76e-01, stepsize=4.00e+00, error=9.52e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15060, objective=2.76e-01, stepsize=8.00e+00, error=4.73e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15070, objective=2.76e-01, stepsize=4.00e+00, error=9.42e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15080, objective=2.76e-01, stepsize=8.00e+00, error=4.70e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15090, objective=2.76e-01, stepsize=4.00e+00, error=9.35e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15100, objective=2.76e-01, stepsize=1.60e+01, error=2.33e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15110, objective=2.76e-01, stepsize=4.00e+00, error=9.29e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15120, objective=2.76e-01, stepsize=4.00e+00, error=9.26e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15130, objective=2.76e-01, stepsize=4.00e+00, error=9.25e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15140, objective=2.76e-01, stepsize=1.60e+01, error=2.31e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15150, objective=2.76e-01, stepsize=8.00e+00, error=4.60e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15160, objective=2.76e-01, stepsize=1.60e+01, error=2.30e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15170, objective=2.76e-01, stepsize=8.00e+00, error=4.59e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15180, objective=2.76e-01, stepsize=1.60e+01, error=2.30e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15190, objective=2.76e-01, stepsize=8.00e+00, error=4.57e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15200, objective=2.76e-01, stepsize=4.00e+00, error=9.15e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15210, objective=2.76e-01, stepsize=8.00e+00, error=4.57e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15220, objective=2.76e-01, stepsize=4.00e+00, error=9.16e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15230, objective=2.76e-01, stepsize=8.00e+00, error=4.57e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15240, objective=2.76e-01, stepsize=4.00e+00, error=9.13e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15250, objective=2.76e-01, stepsize=8.00e+00, error=4.58e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15260, objective=2.76e-01, stepsize=4.00e+00, error=9.15e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15270, objective=2.76e-01, stepsize=1.60e+01, error=2.30e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15280, objective=2.76e-01, stepsize=4.00e+00, error=9.17e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15290, objective=2.76e-01, stepsize=4.00e+00, error=9.17e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15300, objective=2.76e-01, stepsize=4.00e+00, error=9.19e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15310, objective=2.76e-01, stepsize=1.60e+01, error=2.30e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15320, objective=2.76e-01, stepsize=4.00e+00, error=9.17e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15330, objective=2.76e-01, stepsize=8.00e+00, error=4.67e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15340, objective=2.76e-01, stepsize=8.00e+00, error=4.66e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15350, objective=2.76e-01, stepsize=1.60e+01, error=2.34e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15360, objective=2.76e-01, stepsize=8.00e+00, error=4.64e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15370, objective=2.76e-01, stepsize=4.00e+00, error=9.31e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15380, objective=2.76e-01, stepsize=8.00e+00, error=4.64e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15390, objective=2.76e-01, stepsize=4.00e+00, error=9.31e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15400, objective=2.76e-01, stepsize=1.60e+01, error=2.33e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15410, objective=2.76e-01, stepsize=8.00e+00, error=4.70e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15420, objective=2.76e-01, stepsize=1.60e+01, error=2.35e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15430, objective=2.76e-01, stepsize=8.00e+00, error=4.69e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15440, objective=2.76e-01, stepsize=1.60e+01, error=2.35e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15450, objective=2.76e-01, stepsize=8.00e+00, error=4.63e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15460, objective=2.76e-01, stepsize=4.00e+00, error=9.27e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15470, objective=2.76e-01, stepsize=8.00e+00, error=4.61e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15480, objective=2.76e-01, stepsize=4.00e+00, error=9.21e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15490, objective=2.76e-01, stepsize=1.60e+01, error=2.29e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15500, objective=2.76e-01, stepsize=8.00e+00, error=4.55e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15510, objective=2.76e-01, stepsize=1.60e+01, error=2.27e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15520, objective=2.76e-01, stepsize=8.00e+00, error=4.51e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15530, objective=2.76e-01, stepsize=1.60e+01, error=2.25e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15540, objective=2.76e-01, stepsize=8.00e+00, error=4.44e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15550, objective=2.76e-01, stepsize=4.00e+00, error=8.84e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15560, objective=2.76e-01, stepsize=8.00e+00, error=4.39e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15570, objective=2.76e-01, stepsize=4.00e+00, error=8.75e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15580, objective=2.76e-01, stepsize=8.00e+00, error=4.34e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15590, objective=2.76e-01, stepsize=4.00e+00, error=8.60e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15600, objective=2.76e-01, stepsize=8.00e+00, error=4.29e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15610, objective=2.76e-01, stepsize=4.00e+00, error=8.51e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15620, objective=2.76e-01, stepsize=1.60e+01, error=2.12e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15630, objective=2.76e-01, stepsize=4.00e+00, error=8.42e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15640, objective=2.76e-01, stepsize=4.00e+00, error=8.36e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15650, objective=2.76e-01, stepsize=4.00e+00, error=8.33e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15660, objective=2.76e-01, stepsize=1.60e+01, error=2.07e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15670, objective=2.76e-01, stepsize=8.00e+00, error=4.12e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15680, objective=2.76e-01, stepsize=1.60e+01, error=2.05e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15690, objective=2.76e-01, stepsize=8.00e+00, error=4.08e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15700, objective=2.76e-01, stepsize=1.60e+01, error=2.04e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15710, objective=2.76e-01, stepsize=8.00e+00, error=4.04e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15720, objective=2.76e-01, stepsize=4.00e+00, error=8.07e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15730, objective=2.76e-01, stepsize=8.00e+00, error=4.02e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15740, objective=2.76e-01, stepsize=4.00e+00, error=8.03e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15750, objective=2.76e-01, stepsize=8.00e+00, error=4.01e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15760, objective=2.76e-01, stepsize=4.00e+00, error=7.99e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15770, objective=2.76e-01, stepsize=8.00e+00, error=4.00e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15780, objective=2.76e-01, stepsize=4.00e+00, error=7.97e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15790, objective=2.76e-01, stepsize=1.60e+01, error=2.00e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15800, objective=2.76e-01, stepsize=4.00e+00, error=7.98e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15810, objective=2.76e-01, stepsize=4.00e+00, error=7.97e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15820, objective=2.76e-01, stepsize=4.00e+00, error=7.99e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15830, objective=2.76e-01, stepsize=1.60e+01, error=2.00e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15840, objective=2.76e-01, stepsize=4.00e+00, error=7.99e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15850, objective=2.76e-01, stepsize=8.00e+00, error=4.04e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15860, objective=2.76e-01, stepsize=8.00e+00, error=4.04e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15870, objective=2.76e-01, stepsize=1.60e+01, error=2.03e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15880, objective=2.76e-01, stepsize=8.00e+00, error=4.04e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15890, objective=2.76e-01, stepsize=4.00e+00, error=8.10e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15900, objective=2.76e-01, stepsize=8.00e+00, error=4.05e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15910, objective=2.76e-01, stepsize=4.00e+00, error=8.12e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15920, objective=2.76e-01, stepsize=8.00e+00, error=4.06e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15930, objective=2.76e-01, stepsize=4.00e+00, error=8.12e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15940, objective=2.76e-01, stepsize=8.00e+00, error=4.07e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15950, objective=2.76e-01, stepsize=1.60e+01, error=2.04e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15960, objective=2.76e-01, stepsize=1.60e+01, error=2.05e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15970, objective=2.76e-01, stepsize=8.00e+00, error=4.09e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15980, objective=2.76e-01, stepsize=4.00e+00, error=8.18e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 15990, objective=2.76e-01, stepsize=8.00e+00, error=4.08e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 16000, objective=2.76e-01, stepsize=4.00e+00, error=8.17e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 16010, objective=2.76e-01, stepsize=8.00e+00, error=4.08e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 16020, objective=2.76e-01, stepsize=4.00e+00, error=8.14e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 16030, objective=2.76e-01, stepsize=8.00e+00, error=4.09e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 16040, objective=2.76e-01, stepsize=8.00e+00, error=4.08e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 16050, objective=2.76e-01, stepsize=1.60e+01, error=2.04e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 16060, objective=2.76e-01, stepsize=8.00e+00, error=4.05e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 16070, objective=2.76e-01, stepsize=4.00e+00, error=8.08e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 16080, objective=2.76e-01, stepsize=8.00e+00, error=4.03e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 16090, objective=2.76e-01, stepsize=4.00e+00, error=8.04e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 16100, objective=2.76e-01, stepsize=1.60e+01, error=2.01e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 16110, objective=2.76e-01, stepsize=8.00e+00, error=4.01e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 16120, objective=2.76e-01, stepsize=1.60e+01, error=2.00e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 16130, objective=2.76e-01, stepsize=8.00e+00, error=3.99e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 16140, objective=2.76e-01, stepsize=1.60e+01, error=1.99e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 16150, objective=2.76e-01, stepsize=8.00e+00, error=3.95e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 16160, objective=2.76e-01, stepsize=4.00e+00, error=7.89e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n", + "Iteration 16170, objective=2.76e-01, stepsize=4.00e+00, error=7.88e-04, shift sparsity = [9.33e-05 1.00e+00 9.33e-05], duality gap = 0.00e+00\n" + ] + } + ], + "source": [ "\n", - "for _ in range(2000):\n", + "for _ in range(20000):\n", " params, state = update(\n", " params, state,\n", " hyperparameters_prox,\n", @@ -2699,26 +4176,31 @@ " duality_gap.append(jnp.sqrt(((Δ_ravel - D_block_diag @ β_ravel))**2).reshape(-1, len(β_ravel) // 3, order=\"F\").sum(0).mean())\n", " if state.iter_num % 10 == 0:\n", " with np.printoptions(precision=2, floatmode=\"fixed\"):\n", - " print(f\"Iteration {iter[-1]}, objective={obj[-1]:.2e}, stepsize={stepsize[-1]:.2e}, error={error[-1]:.2e}, shift sparsity = {sparsity[-1]}, duality gap = {duality_gap[-1]:.2e}\")" + " print(f\"Iteration {iter[-1]}, objective={obj[-1]:.2e}, stepsize={stepsize[-1]:.2e}, error={error[-1]:.2e}, shift sparsity = {sparsity[-1]}, duality gap = {duality_gap[-1]:.2e}\")\n", + " if state.error < 1e-4:\n", + " break" ] }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 45, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "ProxGradState(iter_num=Array(2000, dtype=int64, weak_type=True), stepsize=Array(8., dtype=float64), error=Array(0.01232012, dtype=float64), aux=None, velocity={'Δ': Array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]], dtype=float64), 'β': {'Delta': Array([-1.86461532, -2.14373595, -1.94838157, ..., 0.57225441,\n", - " -0.15953703, 0.02294486], dtype=float64), 'Omicron_BA1': Array([-1.86461532, -2.14373595, -1.94838157, ..., 0.57225441,\n", - " -0.15953703, 0.02294486], dtype=float64), 'Omicron_BA2': Array([-1.86461532, -2.14373595, -1.94838157, ..., 0.57225441,\n", - " -0.15953703, 0.02294486], dtype=float64)}, 'β0': {'Delta': Array(0.39737314, dtype=float64), 'Omicron_BA1': Array(0., dtype=float64), 'Omicron_BA2': Array(-0.02780172, dtype=float64)}}, t=Array(1002.72414118, dtype=float64, weak_type=True))" + "ProxGradState(iter_num=Array(16174, dtype=int64, weak_type=True), stepsize=Array(32., dtype=float64), error=Array(9.92000471e-05, dtype=float64), aux=None, velocity={'Δ': Array([[-0.10964781, 0.24879308, -0.63019938, ..., -0.63343866,\n", + " 0.14142437, -0.10414721],\n", + " [ 0. , 0. , 0. , ..., 0. ,\n", + " 0. , 0. ],\n", + " [ 0.04833097, -0.21128656, 0.27591585, ..., -0.43975802,\n", + " -0.1786797 , 0.04652405]], dtype=float64), 'β': {'Delta': Array([-0.36658128, -2.5506465 , -2.09876846, ..., 0.285537 ,\n", + " 0.24964971, -0.35133814], dtype=float64), 'Omicron_BA1': Array([-0.25693347, -2.79943958, -1.46856908, ..., 0.91897566,\n", + " 0.10822534, -0.24719093], dtype=float64), 'Omicron_BA2': Array([-0.2086025 , -3.01072614, -1.19265324, ..., 0.47921764,\n", + " -0.07045436, -0.20066688], dtype=float64)}, 'β0': {'Delta': Array(-0.17063019, dtype=float64), 'Omicron_BA1': Array(0., dtype=float64), 'Omicron_BA2': Array(-0.32105412, dtype=float64)}}, t=Array(8090.24612585, dtype=float64, weak_type=True))" ] }, - "execution_count": 38, + "execution_count": 45, "metadata": {}, "output_type": "execute_result" } @@ -2729,22 +4211,12 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 46, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2754,7 +4226,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2764,7 +4236,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2774,7 +4246,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2817,7 +4289,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 42, "metadata": {}, "outputs": [], "source": [ @@ -2827,12 +4299,12 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 43, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2842,7 +4314,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2852,7 +4324,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2879,27 +4351,30 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 44, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'Δ': array([[-0., 0., -0., ..., -0., 0., 0.],\n", - " [ 0., 0., 0., ..., 0., 0., 0.],\n", - " [ 0., 0., 0., ..., -0., 0., 0.]]),\n", - " 'β': {'Delta': Array([-1.86420173, -2.14352146, -1.94780416, ..., 0.57223119,\n", - " -0.15950284, 0.02285615], dtype=float64),\n", - " 'Omicron_BA1': Array([-1.86420173, -2.14352146, -1.94780416, ..., 0.57223119,\n", - " -0.15950284, 0.02285615], dtype=float64),\n", - " 'Omicron_BA2': Array([-1.86420173, -2.14352146, -1.94780416, ..., 0.57223119,\n", - " -0.15950284, 0.02285615], dtype=float64)},\n", - " 'β0': {'Delta': Array(0.39737501, dtype=float64),\n", + "{'Δ': array([[-0.10964385, 0.24878039, -0.63015634, ..., -0.63343957,\n", + " 0.14142168, -0.10414248],\n", + " [ 0. , 0. , 0. , ..., 0. ,\n", + " 0. , 0. ],\n", + " [ 0.04833197, -0.21129491, 0.27592066, ..., -0.43975897,\n", + " -0.17867868, 0.04652497]]),\n", + " 'β': {'Delta': Array([-0.3665856 , -2.55064954, -2.09877187, ..., 0.2855373 ,\n", + " 0.24964739, -0.35134135], dtype=float64),\n", + " 'Omicron_BA1': Array([-0.25694175, -2.79942993, -1.46861553, ..., 0.91897687,\n", + " 0.10822572, -0.24719887], dtype=float64),\n", + " 'Omicron_BA2': Array([-0.20860978, -3.01072484, -1.19269487, ..., 0.4792179 ,\n", + " -0.07045296, -0.20067389], dtype=float64)},\n", + " 'β0': {'Delta': Array(-0.17062913, dtype=float64),\n", " 'Omicron_BA1': Array(0., dtype=float64),\n", - " 'Omicron_BA2': Array(-0.02792787, dtype=float64)}}" + " 'Omicron_BA2': Array(-0.32102417, dtype=float64)}}" ] }, - "execution_count": 42, + "execution_count": 44, "metadata": {}, "output_type": "execute_result" } @@ -2941,7 +4416,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.2" + "version": "3.11.5" } }, "nbformat": 4, diff --git a/pyproject.toml b/pyproject.toml index 130ad40..03e97dc 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -22,7 +22,8 @@ classifiers = [ "Programming Language :: Python :: 3.9", ] keywords = [ - "multidms", + "multidms", + "generalized lasso", "deep", "mutational", "scanning", @@ -36,16 +37,18 @@ keywords = [ requires-python = ">=3.9" dependencies = [ "polyclonal", - "jax[cpu]==0.4.24", + "jax[cpu]>=0.4.29", "jaxopt", "typing_extensions", - "numpy", + "numpy<=1.26.0", "pandas>=2.2.0", "binarymap", "altair==5.1.2", # pandas convert_dtypes bug "matplotlib", "seaborn", "scipy", + "pylops", + "pyproximal", "tqdm", "pandarallel", ] @@ -57,7 +60,9 @@ dev = [ "ruff~=0.0.289", "black~=23.3.0", "notebook", - "sphinx", + # "sphinx", + "sphinx==6.2.1", + "sphinx-autoapi==3.0.0", "nbsphinx", "nbsphinx_link", "bumpver", diff --git a/tests/test_data.py b/tests/test_data.py index 2656e32..7e39f1e 100644 --- a/tests/test_data.py +++ b/tests/test_data.py @@ -1,17 +1,15 @@ """Tests for the Data class and its methods.""" -# import traceback -# import warnings -# import sys - - -# import os import pytest import multidms import numpy as np +import jax.numpy as jnp +from jax.tree_util import tree_flatten import pandas as pd from io import StringIO +import multidms.utils + TEST_FUNC_SCORES = pd.read_csv( StringIO( """ @@ -37,10 +35,16 @@ assert_site_integrity=True, name="test_data", ) - model = multidms.Model(data, PRNGKey=23) +r""" ++++++++++++++++++++++++++++++ +DATA ++++++++++++++++++++++++++++++ +""" + + def test_site_integrity(): """ Test that the site integrity is maintained @@ -136,6 +140,259 @@ def test_conversion_from_subs(): assert data.convert_subs_wrt_ref_seq(("b" if ref == "a" else "a"), "") == bundle +def test_non_identical_mutations_property(): + """Make sure we're getting the correct indicies for the bundle mutations""" + assert jnp.all(data.bundle_idxs["a"] == jnp.repeat(False, len(data.mutations))) + assert jnp.sum(data.bundle_idxs["b"]) == 1 + + +def test_non_identical_conversion(): + """ + Test the conversion to with respect reference wt sequence. + + There are a few cases we will want to test: + + 1. We drop sites (and the relevant variants with muts at those site) + from the training data completely, if there is not information at + a given site for all conditions. This is because we need to be able to + infer the wildtypes for each condition in order to determine whether + or not they should be treated as non-identical. + + 2. Non identical "bundle muts" get encoded as 1 + in the non reference condition genotype + + 3. Non identical site reversions don't exist + in the non reference variants reference genotype + """ + data = multidms.Data( + TEST_FUNC_SCORES, + alphabet=multidms.AAS_WITHSTOP, + collapse_identical_variants="mean", + reference="a", + assert_site_integrity=True, + ) + + assert np.all( + data.binarymaps["a"].binary_variants.todense() + == [[0, 0, 1, 0], [0, 0, 0, 1], [1, 0, 0, 0], [0, 1, 0, 0]] + ) + + assert np.all( + data.binarymaps["b"].binary_variants.todense() + == [[1, 0, 1, 0], [1, 0, 0, 0], [1, 0, 0, 1], [0, 0, 0, 0], [0, 0, 0, 1]] + ) + + +def test_single_mut_encodings(): + """ + Test that the binary encoding of single mutations + is correct. + """ + data = multidms.Data( + TEST_FUNC_SCORES, + alphabet=multidms.AAS_WITHSTOP, + reference="a", + assert_site_integrity=False, + ) + single_mut_encodings = data.single_mut_encodings + assert np.all( + np.array(single_mut_encodings["a"].todense()).flatten() + == np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]).flatten() + ) + assert np.all( + np.array(single_mut_encodings["b"].todense()).flatten() + == np.array([[1, 0, 1, 0], [0, 1, 1, 0], [0, 0, 1, 0], [0, 0, 0, 1]]).flatten() + ) + + +def test_plotting_fxns(): + """Test that the plotting functions work""" + Data = multidms.Data( + TEST_FUNC_SCORES, + alphabet=multidms.AAS_WITHSTOP, + reference="a", + assert_site_integrity=False, + ) + + Data.plot_times_seen_hist(show=False) + Data.plot_func_score_boxplot(show=False) + + +r""" ++++++++++++++++++++++++++++++ +UTILS ++++++++++++++++++++++++++++++ +""" + + +def test_explode_params_dict(): + """Test multidms.model_collection.explode_params_dict""" + params_dict = {"a": [1, 2], "b": [3]} + exploded = multidms.utils.explode_params_dict(params_dict) + assert exploded == [{"a": 1, "b": 3}, {"a": 2, "b": 3}] + + +def test_difference_matrix(): + """ + Test that the difference matrix performs + the correct linear operation + """ + # test difference matrix at 5 different n's + for n in range(1, 5): + test_vec = jnp.array(range(1, n + 1))[:, None] + expected_result = jnp.array(range(n))[:, None] + D = multidms.utils.difference_matrix(n) + assert jnp.all(D @ test_vec == expected_result) + + +def test_transform_inverse(): + """ + Test that the transform operation is + its own inverse. + """ + model = multidms.Model(data, multidms.biophysical.identity_activation, PRNGKey=23) + params = model._scaled_data_params + bundle_idxs = data.bundle_idxs + double_inverse = multidms.utils.transform( + multidms.utils.transform(params, bundle_idxs), bundle_idxs + ) + assert np.all(params["beta"]["a"] == double_inverse["beta"]["a"]) + assert np.all(params["beta"]["b"] == double_inverse["beta"]["b"]) + assert np.all(params["beta0"]["a"] == double_inverse["beta0"]["a"]) + assert np.all(params["beta0"]["b"] == double_inverse["beta0"]["b"]) + + +r""" ++++++++++++++++++++++++++++++ +MODEL ++++++++++++++++++++++++++++++ +""" + + +def test_linear_model_fit_simple(): + """ + Simple test to see that the linear model + fits without error. + """ + data = multidms.Data( + TEST_FUNC_SCORES.query("condition == 'a'"), + alphabet=multidms.AAS_WITHSTOP, + reference="a", + assert_site_integrity=False, + ) + model = multidms.Model(data, multidms.biophysical.identity_activation, PRNGKey=23) + model.fit(maxiter=2, warn_unconverged=False) + + # test all plotting fxn's + model.plot_pred_accuracy(show=False) + model.plot_epistasis(show=False) + model.plot_param_hist("beta_a", show=False) + model.plot_param_heatmap("beta_a", show=False) + _ = model.mut_param_heatmap("beta") + + +def test_linear_model_multi_cond_fit_simple(): + """ + Simple test to see that the linear model + fits multiple conditions without error. + """ + data = multidms.Data( + TEST_FUNC_SCORES, + alphabet=multidms.AAS_WITHSTOP, + reference="a", + assert_site_integrity=False, + ) + model = multidms.Model(data, multidms.biophysical.identity_activation, PRNGKey=23) + model.fit(maxiter=2, warn_unconverged=False) + + # test all plotting fxn's + model.plot_pred_accuracy(show=False) + model.plot_epistasis(show=False) + model.plot_param_hist("shift_b", show=False) + model.plot_param_heatmap("shift_b", show=False) + model.plot_shifts_by_site("b", show=False) + _ = model.mut_param_heatmap("shift") + + +def test_fit_simple(): + """ + Simple test to see that the single-condition model + fits without error. + """ + data = multidms.Data( + TEST_FUNC_SCORES.query("condition == 'a'"), + alphabet=multidms.AAS_WITHSTOP, + reference="a", + assert_site_integrity=False, + ) + model = multidms.Model(data, PRNGKey=23) + loss = model.loss + model.fit(maxiter=2, warn_unconverged=False) + assert loss != model.loss + + # test all plotting fxn's + model.plot_pred_accuracy(show=False) + model.plot_epistasis(show=False) + model.plot_param_hist("beta_a", show=False) + model.plot_param_heatmap("beta_a", show=False) + _ = model.mut_param_heatmap("beta") + + +def test_multi_cond_fit_simple(): + """ + Simple test to make sure the multi-condition model + fits without error. + """ + data = multidms.Data( + TEST_FUNC_SCORES, + alphabet=multidms.AAS_WITHSTOP, + reference="a", + assert_site_integrity=False, + ) + model = multidms.Model(data, PRNGKey=23) + model.fit(maxiter=2, warn_unconverged=False) + + # test all plotting fxn's + model.plot_pred_accuracy(show=False) + model.plot_epistasis(show=False) + model.plot_param_hist("shift_b", show=False) + model.plot_param_heatmap("shift_b", show=False) + model.plot_shifts_by_site("b", show=False) + _ = model.mut_param_heatmap() + + +def test_scaled_predictions(): + """ + Test that the scaled data and parameter predictions + are the same as unscaled predictions. + """ + model = multidms.Model(data, PRNGKey=23) + model.fit(maxiter=2, warn_unconverged=False) + pred_fxn = model.model_components["f"] + scaled_params = model._scaled_data_params + scaled_data = model.data.scaled_training_data["X"] + unscaled_params = model.params + unscaled_data = model.data.training_data["X"] + for condition in model.data.conditions: + scaled_d_params = { + "beta": scaled_params["beta"][condition], + "beta0": scaled_params["beta0"][condition], + "theta": scaled_params["theta"], + } + scaled_d_data = scaled_data[condition] + scaled_predictions = pred_fxn(scaled_d_params, scaled_d_data) + + unscaled_d_params = { + "beta": unscaled_params["beta"][condition], + "beta0": unscaled_params["beta0"][condition], + "theta": unscaled_params["theta"], + } + unscaled_d_data = unscaled_data[condition] + unscaled_predictions = pred_fxn(unscaled_d_params, unscaled_d_data) + + assert np.all(scaled_predictions == unscaled_predictions) + + def test_wildtype_mutant_predictions(): """ test that the wildtype predictions are correct @@ -151,27 +408,36 @@ def test_wildtype_mutant_predictions(): model.fit(maxiter=2, warn_unconverged=False) wildtype_df = model.wildtype_df for condition in model.data.conditions: - byhand_latent = model.params["beta_naught"][0] + latent_offset = model.params["beta0"][condition] + byhand_wt_latent_pred = latent_offset + if condition != model.data.reference: converted_subs = model.data.convert_subs_wrt_ref_seq(condition, "") bmap = model.data.binarymaps[model.data.reference] enc = bmap.sub_str_to_binary(converted_subs) assert sum(enc) == len(converted_subs.split()) - mut_params = model.get_mutations_df(phenotype_as_effect=False).query( + mut_params = model.get_mutations_df().query( "mutation.isin(@converted_subs.split())" ) - latent = (mut_params.beta + mut_params[f"shift_{condition}"]).sum() - offset = model.params["beta_naught"] + model.params[f"alpha_{condition}"] - byhand_latent = latent + offset[0] + bundle_effect = mut_params[f"beta_{condition}"].sum() + + # first, check that the bundle effect of conditional beta's + # is the same as the reference beta's plus the shift + reference_beta = mut_params[f"beta_{model.data.reference}"] + conditional_shift = mut_params[f"shift_{condition}"] + bundle_effect_beta_shift = (reference_beta + conditional_shift).sum() + assert np.isclose(bundle_effect, bundle_effect_beta_shift) + + byhand_wt_latent_pred += bundle_effect # check latent - pred_latent = wildtype_df.loc[condition, "predicted_latent"] - assert np.isclose(byhand_latent, pred_latent) + method_wt_latent_pred = wildtype_df.loc[condition, "predicted_latent"] + assert np.isclose(byhand_wt_latent_pred, method_wt_latent_pred) # check wt functional score sig_params = model.params["theta"] scale, bias = sig_params["ge_scale"], sig_params["ge_bias"] - byhand_func_score = scale / (1 + np.exp(-1 * byhand_latent)) + bias + byhand_func_score = scale / (1 + np.exp(-1 * byhand_wt_latent_pred)) + bias pred_func_score = wildtype_df.loc[condition, "predicted_func_score"] assert np.isclose(byhand_func_score, pred_func_score) @@ -190,73 +456,57 @@ def test_mutations_df(): ) model = multidms.Model(data, PRNGKey=23) model.fit(maxiter=2, warn_unconverged=False) - sig_params = model.params["theta"] - scale, bias = sig_params["ge_scale"], sig_params["ge_bias"] - mutations_df = model.get_mutations_df(phenotype_as_effect=False) - for i, mutation in enumerate(model.data.mutations): - effect = model.params["beta"][i] - for condition in model.data.conditions: - shift = model.params[f"shift_{condition}"][i] - byhand_latent = ( - effect - + shift - + model.params["beta_naught"] - + model.params[f"alpha_{condition}"] - ) - byhand_func_score = scale / (1 + np.exp(-1 * byhand_latent)) + bias - assert np.isclose( - byhand_func_score, - mutations_df.loc[mutation, f"predicted_func_score_{condition}"], - ) - - -def test_non_identical_conversion(): - """ - Test the conversion to with respect reference wt sequence. - - There are a few cases we will want to test: - - 1. We drop sites (and the relevant variants with muts at those site) - from the training data completely, if there is not information at - a given site for all conditions. This is because we need to be able to - infer the wildtypes for each condition in order to determine whether - or not they should be treated as non-identical. - 2. Non identical "bundle muts" get encoded as 1 - in the non reference condition genotype + # We want to make sure the predictions in this method are as expected + mutations_df = model.get_mutations_df() - 3. Non identical site reversions don't exist - in the non reference variants reference genotype - """ - data = multidms.Data( - TEST_FUNC_SCORES, - alphabet=multidms.AAS_WITHSTOP, - collapse_identical_variants="mean", - reference="a", - assert_site_integrity=True, - ) + # we'll compare it to predictions done by hand + sig_params = model.params["theta"] + scale, bias = sig_params["ge_scale"][0], sig_params["ge_bias"][0] + wildtype_df = model.wildtype_df - assert np.all( - data.binarymaps["a"].binary_variants.todense() - == [[0, 0, 1, 0], [0, 0, 0, 1], [1, 0, 0, 0], [0, 1, 0, 0]] - ) + for condition in model.data.conditions: + wildtype_func_score = wildtype_df.loc[condition, "predicted_func_score"] + for i, mutation in enumerate(model.data.mutations): + mut_df_pred = mutations_df.loc[ + mutation, f"predicted_func_score_{condition}" + ] + + ref_effect = model.params["beta"][data.reference][i] + shift = model.params["shift"][f"{condition}"][i] + effect = ref_effect + shift + assert np.isclose(effect, model.params["beta"][condition][i]) + + converted_wrt_ref = model.data.convert_subs_wrt_ref_seq(condition, mutation) + binarymap = model.data.binarymaps[condition] + converted_wrt_ref_enc = binarymap.sub_str_to_binary(converted_wrt_ref) + bool_enc = converted_wrt_ref_enc.astype(bool) + additive_effect = sum(model.params["beta"][condition][bool_enc]) + latent_offset = model.params["beta0"][condition][0] + byhand_latent = additive_effect + latent_offset + byhand_func_score = scale / (1 + np.exp(-1 * byhand_latent)) + bias + byhand_func_score_effect = byhand_func_score - wildtype_func_score - assert np.all( - data.binarymaps["b"].binary_variants.todense() - == [[1, 0, 1, 0], [1, 0, 0, 0], [1, 0, 0, 1], [0, 0, 0, 0], [0, 0, 0, 1]] - ) + assert np.isclose( + byhand_func_score_effect, + mut_df_pred, + ) def test_model_PRNGKey(): """ Simply test the instantiation of a model with different PRNG keys to make sure the seed structure truly ensures the same parameter - initialization values + initialization values. Note the only random initialization in the + models is with the Neural network non-linearity model. """ - model_1 = multidms.Model(data, PRNGKey=23) - model_2 = multidms.Model(data, PRNGKey=23) - for param, values in model_1.params.items(): - assert np.all(values == model_2.params[param]) + model_1 = multidms.Model( + data, epistatic_model=multidms.biophysical.nn_global_epistasis, PRNGKey=23 + ) + model_2 = multidms.Model( + data, epistatic_model=multidms.biophysical.nn_global_epistasis, PRNGKey=23 + ) + assert tree_flatten(model_1.params)[1] == tree_flatten(model_2.params)[1] def test_lower_bound(): @@ -350,16 +600,62 @@ def test_model_fit_and_determinism(): model_1.fit(maxiter=5, warn_unconverged=False) model_2.fit(maxiter=5, warn_unconverged=False) + assert tree_flatten(model_1.params)[1] == tree_flatten(model_2.params)[1] - for param, values in model_1.params.items(): - assert np.all(values == model_2.params[param]) +def test_model_get_df_loss(): + """ + Test that the loss is correctly calculated + by comparing the result of model.loss() to the results of model.get_df_loss() + when given the training dataframe. + """ + model = multidms.Model(data, PRNGKey=23) + model.fit(maxiter=2, warn_unconverged=False) + loss = model.loss + df_loss = model.get_df_loss(TEST_FUNC_SCORES) + assert loss == df_loss -def test_explode_params_dict(): - """Test multidms.model_collection.explode_params_dict""" - params_dict = {"a": [1, 2], "b": [3]} - exploded = multidms.model_collection._explode_params_dict(params_dict) - assert exploded == [{"a": 1, "b": 3}, {"a": 2, "b": 3}] + # also test that is it's the same if we add an unknown variant to training + test_with_unknown = TEST_FUNC_SCORES.copy() + test_with_unknown.loc[len(test_with_unknown)] = ["a", "E100T MIE", 0.2] + df_loss = model.get_df_loss(test_with_unknown) + assert loss == df_loss + + +def test_model_get_df_loss_conditional(): + """ + Test that the loss is correctly calculated + across each condition, by summing the conditions to be sure + they match the total loss. + """ + model = multidms.Model(data, PRNGKey=23) + model.fit(maxiter=2, warn_unconverged=False) + loss = model.loss + df_loss = model.get_df_loss(TEST_FUNC_SCORES, conditional=True) + # remove full and compare sum of the rest + df_loss.pop("total") + assert loss == sum(df_loss.values()) / len(df_loss) + + +def test_conditional_loss(): + """ + Test that the conditional loss is correctly calculated + by comparing the result of model.conditional_loss() + to the results of model.get_df_loss() + when given the training dataframe. + """ + model = multidms.Model(data, PRNGKey=23) + model.fit(maxiter=2, warn_unconverged=False) + loss = model.conditional_loss + df_loss = model.get_df_loss(TEST_FUNC_SCORES, conditional=True) + assert loss == df_loss + + +r""" ++++++++++++++++++++++++++++++ +MODEL_COLLECTION ++++++++++++++++++++++++++++++ +""" def test_fit_models(): @@ -382,12 +678,52 @@ def test_fit_models(): params, n_threads=-1, ) + # assert False mc = multidms.model_collection.ModelCollection(fit_models_df) tall_combined = mc.split_apply_combine_muts(groupby=("scale_coeff_lasso_shift")) assert len(tall_combined) == 2 * len(data.mutations_df) assert list(tall_combined.index.names) == ["scale_coeff_lasso_shift"] +def test_ModelCollection_mut_param_dataset_correlation(): + """ + Test that the correlation between the mutational + parameter estimates across conditions is correct. + by correlating two deterministic model fits from identical + datasets, meaning they should have a correlation of 1.0. + """ + data_rep1 = multidms.Data( + TEST_FUNC_SCORES, + alphabet=multidms.AAS_WITHSTOP, + reference="a", + assert_site_integrity=False, + name="rep1", + ) + + data_rep2 = multidms.Data( + TEST_FUNC_SCORES, + alphabet=multidms.AAS_WITHSTOP, + reference="a", + assert_site_integrity=False, + name="rep2", + ) + + params = { + "dataset": [data_rep1, data_rep2], + "maxiter": [1], + "scale_coeff_lasso_shift": [0.0], + } + + _, _, fit_models_df = multidms.model_collection.fit_models( + params, + n_threads=-1, + ) + mc = multidms.model_collection.ModelCollection(fit_models_df) + chart, data = mc.mut_param_dataset_correlation(return_data=True) + + assert np.all(data["correlation"] == 1.0) + + def test_ModelCollection_charts(): """ Test fitting two different models in @@ -414,71 +750,6 @@ def test_ModelCollection_charts(): mc.shift_sparsity() -def test_data_names(): - """ - Test that the default data names are correctly - updated as new Data objects are created within a - single python session. - """ - num_datasets = multidms.Data.counter - for i in range(3): - d_i = multidms.Data( - TEST_FUNC_SCORES, - alphabet=multidms.AAS_WITHSTOP, - reference="a", - assert_site_integrity=False, - ) - assert d_i.name == f"Data-{num_datasets + i}" - - -def test_model_get_df_loss(): - """ - Test that the loss is correctly calculated - by comparing the result of model.loss() to the results of model.get_df_loss() - when given the training dataframe. - """ - model = multidms.Model(data, PRNGKey=23) - model.fit(maxiter=2, warn_unconverged=False) - loss = model.loss - df_loss = model.get_df_loss(TEST_FUNC_SCORES) - assert loss == df_loss - - # also test that is it's the same if we add an unknown variant to training - test_with_unknown = TEST_FUNC_SCORES.copy() - test_with_unknown.loc[len(test_with_unknown)] = ["a", "E100T MIE", 0.2] - df_loss = model.get_df_loss(test_with_unknown) - assert loss == df_loss - - -def test_model_get_df_loss_conditional(): - """ - Test that the loss is correctly calculated - across each condition, by summing the conditions to be sure - they match the total loss. - """ - model = multidms.Model(data, PRNGKey=23) - model.fit(maxiter=2, warn_unconverged=False) - loss = model.loss - df_loss = model.get_df_loss(TEST_FUNC_SCORES, conditional=True) - # remove full and compare sum of the rest - df_loss.pop("total") - assert loss == sum(df_loss.values()) - - -def test_conditional_loss(): - """ - Test that the conditional loss is correctly calculated - by comparing the result of model.conditional_loss() - to the results of model.get_df_loss() - when given the training dataframe. - """ - model = multidms.Model(data, PRNGKey=23) - model.fit(maxiter=2, warn_unconverged=False) - loss = model.conditional_loss - df_loss = model.get_df_loss(TEST_FUNC_SCORES, conditional=True) - assert loss == df_loss - - def test_ModelCollection_get_conditional_loss_df(): """ Test that correctness of the conditional loss df @@ -508,22 +779,3 @@ def test_ModelCollection_get_conditional_loss_df(): # to have a row for each model-condition-split (training/validation) pair # + total loss assert df_loss.shape[0] == n_expected_training_loss_rows * 2 - - -def test_single_vs_multistep_acceleration(): - """ - We currently approach the model optimization problem with - a multi-step approach, where each step re-initializes the jaxopt.ProximalGradient - objects before fitting the latest parameters from the previous step for some number - of iterations per step. This behavior affects the FISTA acceleration, which is - re-set at each step. We want to make sure that the multi-step approach - is identical to a single step if we are remove the acceleration. - """ - model = multidms.Model(data, PRNGKey=23) - model.fit(maxiter=4, acceleration=False, warn_unconverged=False) - loss = model.loss - model = multidms.Model(data, PRNGKey=23) - for i in range(2): - model.fit(maxiter=2, acceleration=False, warn_unconverged=False) - loss_no_accel = model.loss - assert loss == loss_no_accel