Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
than k neighbors are available for a missing value.
print_interval : int
min_value : float
Minimum possible imputed value
max_value : float
Maximum possible imputed value
normalizer : object
Any object (such as BiScaler) with fit() and transform() methods
verbose : bool
"""
Solver.__init__(
self,
min_value=min_value,
max_value=max_value,
normalizer=normalizer)
self.k = k
self.verbose = verbose
self.orientation = orientation
self.print_interval = print_interval
if use_argpartition:
self._impute_fn = knn_impute_with_argpartition
else:
self._impute_fn = knn_impute_few_observed
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import cvxpy
from .solver import Solver
from sklearn.utils import check_array
class NuclearNormMinimization(Solver):
"""
Simple implementation of "Exact Matrix Completion via Convex Optimization"
by Emmanuel Candes and Benjamin Recht using cvxpy.
"""
def __init__(
self,
require_symmetric_solution=False,
min_value=None,
max_value=None,
error_tolerance=0.0001,
max_iters=50000,
verbose=True):
"""
Parameters
----------
is by default scaled by np.linalg.norm(np.dot(X.T,X)).
Sensible lambda_regs to try: 0.1, 0.01, 0.001, 0.0001.
n_nearest_columns : int
Number of other columns to use to estimate current column.
Useful when number of columns is huge.
Default is to use all columns.
init_fill_method : str
Valid values: {"mean", "median", or "random"}
(the latter meaning fill with random samples from the observed
values of a column)
verbose : boolean
"""
Solver.__init__(
self,
n_imputations=n_imputations,
min_value=min_value,
max_value=max_value,
fill_method=init_fill_method)
self.visit_sequence = visit_sequence
self.n_burn_in = n_burn_in
self.n_pmm_neighbors = n_pmm_neighbors
self.impute_type = impute_type
self.model = model
self.n_nearest_columns = n_nearest_columns
self.verbose = verbose
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import absolute_import, print_function, division
from collections import deque
import numpy as np
from six.moves import range
from .neuralnet_helpers import make_network
from .common import masked_mae
from .solver import Solver
class AutoEncoder(Solver):
"""
Neural network which takes as an input a vector of feature values and a
binary mask of indicating which features are missing. It's trained
on reconstructing the non-missing values and hopefully achieves
generalization due to a "bottleneck" hidden layer that is smaller than
the input size.
"""
def __init__(
self,
hidden_activation="tanh",
output_activation="linear",
hidden_layer_sizes=None,
optimizer="adam",
dropout_probability=0,
batch_size=32,
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from sklearn.decomposition import TruncatedSVD
from sklearn.utils import check_array
import numpy as np
from .solver import Solver
from .common import masked_mae
F32PREC = np.finfo(np.float32).eps
class IterativeSVD(Solver):
def __init__(
self,
rank=10,
convergence_threshold=0.00001,
max_iters=200,
gradual_rank_increase=True,
svd_algorithm="arpack",
init_fill_method="zero",
min_value=None,
max_value=None,
verbose=True):
Solver.__init__(
self,
fill_method=init_fill_method,
min_value=min_value,
max_value=max_value)
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import absolute_import, print_function, division
from time import time
from six.moves import range
import numpy as np
from .bayesian_ridge_regression import BayesianRidgeRegression
from .solver import Solver
class MICE(Solver):
"""
Basic implementation of MICE package from R.
This version assumes all of the columns are ordinal,
and uses ridge regression.
Parameters
----------
visit_sequence : str
Possible values: "monotone" (default), "roman", "arabic",
"revmonotone".
n_imputations : int
Defaults to 100
n_burn_in : int
Defaults to 10