#!/usr/bin/env python
# -*- encoding: utf-8 -*-
#
# This file is auto-generated by h2o-3/h2o-bindings/bin/gen_python.py
# Copyright 2016 H2O.ai;  Apache License Version 2.0 (see LICENSE for details)
#
from __future__ import absolute_import, division, print_function, unicode_literals

from h2o.estimators.estimator_base import H2OEstimator
from h2o.exceptions import H2OValueError
from h2o.frame import H2OFrame
from h2o.utils.typechecks import assert_is_type, Enum, numeric


class H2OSingularValueDecompositionEstimator(H2OEstimator):
    """
    Singular Value Decomposition

    """

    algo = "svd"
    supervised_learning = False

    def __init__(self,
                 model_id=None,  # type: Optional[Union[None, str, H2OEstimator]]
                 training_frame=None,  # type: Optional[Union[None, str, H2OFrame]]
                 validation_frame=None,  # type: Optional[Union[None, str, H2OFrame]]
                 ignored_columns=None,  # type: Optional[List[str]]
                 ignore_const_cols=True,  # type: bool
                 score_each_iteration=False,  # type: bool
                 transform="none",  # type: Literal["none", "standardize", "normalize", "demean", "descale"]
                 svd_method="gram_s_v_d",  # type: Literal["gram_s_v_d", "power", "randomized"]
                 nv=1,  # type: int
                 max_iterations=1000,  # type: int
                 seed=-1,  # type: int
                 keep_u=True,  # type: bool
                 u_name=None,  # type: Optional[str]
                 use_all_factor_levels=True,  # type: bool
                 max_runtime_secs=0.0,  # type: float
                 export_checkpoints_dir=None,  # type: Optional[str]
                 ):
        """
        :param model_id: Destination id for this model; auto-generated if not specified.
               Defaults to ``None``.
        :type model_id: Union[None, str, H2OEstimator], optional
        :param training_frame: Id of the training data frame.
               Defaults to ``None``.
        :type training_frame: Union[None, str, H2OFrame], optional
        :param validation_frame: Id of the validation data frame.
               Defaults to ``None``.
        :type validation_frame: Union[None, str, H2OFrame], optional
        :param ignored_columns: Names of columns to ignore for training.
               Defaults to ``None``.
        :type ignored_columns: List[str], optional
        :param ignore_const_cols: Ignore constant columns.
               Defaults to ``True``.
        :type ignore_const_cols: bool
        :param score_each_iteration: Whether to score during each iteration of model training.
               Defaults to ``False``.
        :type score_each_iteration: bool
        :param transform: Transformation of training data
               Defaults to ``"none"``.
        :type transform: Literal["none", "standardize", "normalize", "demean", "descale"]
        :param svd_method: Method for computing SVD (Caution: Randomized is currently experimental and unstable)
               Defaults to ``"gram_s_v_d"``.
        :type svd_method: Literal["gram_s_v_d", "power", "randomized"]
        :param nv: Number of right singular vectors
               Defaults to ``1``.
        :type nv: int
        :param max_iterations: Maximum iterations
               Defaults to ``1000``.
        :type max_iterations: int
        :param seed: RNG seed for k-means++ initialization
               Defaults to ``-1``.
        :type seed: int
        :param keep_u: Save left singular vectors?
               Defaults to ``True``.
        :type keep_u: bool
        :param u_name: Frame key to save left singular vectors
               Defaults to ``None``.
        :type u_name: str, optional
        :param use_all_factor_levels: Whether first factor level is included in each categorical expansion
               Defaults to ``True``.
        :type use_all_factor_levels: bool
        :param max_runtime_secs: Maximum allowed runtime in seconds for model training. Use 0 to disable.
               Defaults to ``0.0``.
        :type max_runtime_secs: float
        :param export_checkpoints_dir: Automatically export generated models to this directory.
               Defaults to ``None``.
        :type export_checkpoints_dir: str, optional
        """
        super(H2OSingularValueDecompositionEstimator, self).__init__()
        self._parms = {}
        self._id = self._parms['model_id'] = model_id
        self.training_frame = training_frame
        self.validation_frame = validation_frame
        self.ignored_columns = ignored_columns
        self.ignore_const_cols = ignore_const_cols
        self.score_each_iteration = score_each_iteration
        self.transform = transform
        self.svd_method = svd_method
        self.nv = nv
        self.max_iterations = max_iterations
        self.seed = seed
        self.keep_u = keep_u
        self.u_name = u_name
        self.use_all_factor_levels = use_all_factor_levels
        self.max_runtime_secs = max_runtime_secs
        self.export_checkpoints_dir = export_checkpoints_dir
        self._parms["_rest_version"] = 99

    @property
    def training_frame(self):
        """
        Id of the training data frame.

        Type: ``Union[None, str, H2OFrame]``.

        :examples:

        >>> arrests = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/pca_test/USArrests.csv")
        >>> fit_h2o = H2OSingularValueDecompositionEstimator()
        >>> fit_h2o.train(x=list(range(4)), training_frame=arrests)
        >>> fit_h2o
        """
        return self._parms.get("training_frame")

    @training_frame.setter
    def training_frame(self, training_frame):
        self._parms["training_frame"] = H2OFrame._validate(training_frame, 'training_frame')

    @property
    def validation_frame(self):
        """
        Id of the validation data frame.

        Type: ``Union[None, str, H2OFrame]``.

        :examples:

        >>> arrests = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/pca_test/USArrests.csv")
        >>> train, valid = arrests.split_frame(ratios=[.8])
        >>> fit_h2o = H2OSingularValueDecompositionEstimator()
        >>> fit_h2o.train(x=list(range(4)),
        ...               training_frame=train,
        ...               validation_frame=valid)
        >>> fit_h2o
        """
        return self._parms.get("validation_frame")

    @validation_frame.setter
    def validation_frame(self, validation_frame):
        self._parms["validation_frame"] = H2OFrame._validate(validation_frame, 'validation_frame')

    @property
    def ignored_columns(self):
        """
        Names of columns to ignore for training.

        Type: ``List[str]``.
        """
        return self._parms.get("ignored_columns")

    @ignored_columns.setter
    def ignored_columns(self, ignored_columns):
        assert_is_type(ignored_columns, None, [str])
        self._parms["ignored_columns"] = ignored_columns

    @property
    def ignore_const_cols(self):
        """
        Ignore constant columns.

        Type: ``bool``, defaults to ``True``.

        :examples:

        >>> arrests = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/pca_test/USArrests.csv")
        >>> fit_h2o = H2OSingularValueDecompositionEstimator(ignore_const_cols=False,
        ...                                                  nv=4)
        >>> fit_h2o.train(x=list(range(4)), training_frame=arrests)
        >>> fit_h2o
        """
        return self._parms.get("ignore_const_cols")

    @ignore_const_cols.setter
    def ignore_const_cols(self, ignore_const_cols):
        assert_is_type(ignore_const_cols, None, bool)
        self._parms["ignore_const_cols"] = ignore_const_cols

    @property
    def score_each_iteration(self):
        """
        Whether to score during each iteration of model training.

        Type: ``bool``, defaults to ``False``.

        :examples:

        >>> arrests = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/pca_test/USArrests.csv")
        >>> fit_h2o = H2OSingularValueDecompositionEstimator(nv=4,
        ...                                                  score_each_iteration=True)
        >>> fit_h2o.train(x=list(range(4)), training_frame=arrests)
        >>> fit_h2o
        """
        return self._parms.get("score_each_iteration")

    @score_each_iteration.setter
    def score_each_iteration(self, score_each_iteration):
        assert_is_type(score_each_iteration, None, bool)
        self._parms["score_each_iteration"] = score_each_iteration

    @property
    def transform(self):
        """
        Transformation of training data

        Type: ``Literal["none", "standardize", "normalize", "demean", "descale"]``, defaults to ``"none"``.

        :examples:

        >>> arrests = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/pca_test/USArrests.csv")
        >>> fit_h2o = H2OSingularValueDecompositionEstimator(nv=4,
        ...                                                  transform="standardize",
        ...                                                  max_iterations=2000)
        >>> fit_h2o.train(x=list(range(4)), training_frame=arrests)
        >>> fit_h2o
        """
        return self._parms.get("transform")

    @transform.setter
    def transform(self, transform):
        assert_is_type(transform, None, Enum("none", "standardize", "normalize", "demean", "descale"))
        self._parms["transform"] = transform

    @property
    def svd_method(self):
        """
        Method for computing SVD (Caution: Randomized is currently experimental and unstable)

        Type: ``Literal["gram_s_v_d", "power", "randomized"]``, defaults to ``"gram_s_v_d"``.

        :examples:

        >>> arrests = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/pca_test/USArrests.csv")
        >>> fit_h2o = H2OSingularValueDecompositionEstimator(svd_method="power")
        >>> fit_h2o.train(x=list(range(4)), training_frame=arrests)
        >>> fit_h2o
        """
        return self._parms.get("svd_method")

    @svd_method.setter
    def svd_method(self, svd_method):
        assert_is_type(svd_method, None, Enum("gram_s_v_d", "power", "randomized"))
        self._parms["svd_method"] = svd_method

    @property
    def nv(self):
        """
        Number of right singular vectors

        Type: ``int``, defaults to ``1``.

        :examples:

        >>> arrests = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/pca_test/USArrests.csv")
        >>> fit_h2o = H2OSingularValueDecompositionEstimator(nv=4,
        ...                                                  transform="standardize",
        ...                                                  max_iterations=2000)
        >>> fit_h2o.train(x=list(range(4)), training_frame=arrests)
        >>> fit_h2o
        """
        return self._parms.get("nv")

    @nv.setter
    def nv(self, nv):
        assert_is_type(nv, None, int)
        self._parms["nv"] = nv

    @property
    def max_iterations(self):
        """
        Maximum iterations

        Type: ``int``, defaults to ``1000``.

        :examples:

        >>> arrests = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/pca_test/USArrests.csv")
        >>> fit_h2o = H2OSingularValueDecompositionEstimator(nv=4,
        ...                                                  transform="standardize",
        ...                                                  max_iterations=2000)
        >>> fit_h2o.train(x=list(range(4)), training_frame=arrests)
        >>> fit_h2o
        """
        return self._parms.get("max_iterations")

    @max_iterations.setter
    def max_iterations(self, max_iterations):
        assert_is_type(max_iterations, None, int)
        self._parms["max_iterations"] = max_iterations

    @property
    def seed(self):
        """
        RNG seed for k-means++ initialization

        Type: ``int``, defaults to ``-1``.

        :examples:

        >>> arrests = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/pca_test/USArrests.csv")
        >>> fit_h2o = H2OSingularValueDecompositionEstimator(nv=4, seed=-3)
        >>> fit_h2o.train(x=list(range(4)), training_frame=arrests)
        >>> fit_h2o
        """
        return self._parms.get("seed")

    @seed.setter
    def seed(self, seed):
        assert_is_type(seed, None, int)
        self._parms["seed"] = seed

    @property
    def keep_u(self):
        """
        Save left singular vectors?

        Type: ``bool``, defaults to ``True``.

        :examples:

        >>> arrests = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/pca_test/USArrests.csv")
        >>> fit_h2o = H2OSingularValueDecompositionEstimator(keep_u=False)
        >>> fit_h2o.train(x=list(range(4)), training_frame=arrests)
        >>> fit_h2o
        """
        return self._parms.get("keep_u")

    @keep_u.setter
    def keep_u(self, keep_u):
        assert_is_type(keep_u, None, bool)
        self._parms["keep_u"] = keep_u

    @property
    def u_name(self):
        """
        Frame key to save left singular vectors

        Type: ``str``.

        :examples:

        >>> arrests = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/pca_test/USArrests.csv")
        >>> fit_h2o = H2OSingularValueDecompositionEstimator(u_name="fit_h2o")
        >>> fit_h2o.train(x=list(range(4)), training_frame=arrests)
        >>> fit_h2o.u_name
        >>> fit_h2o
        """
        return self._parms.get("u_name")

    @u_name.setter
    def u_name(self, u_name):
        assert_is_type(u_name, None, str)
        self._parms["u_name"] = u_name

    @property
    def use_all_factor_levels(self):
        """
        Whether first factor level is included in each categorical expansion

        Type: ``bool``, defaults to ``True``.

        :examples:

        >>> arrests = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/pca_test/USArrests.csv")
        >>> fit_h2o = H2OSingularValueDecompositionEstimator(use_all_factor_levels=False)
        >>> fit_h2o.train(x=list(range(4)), training_frame=arrests)
        >>> fit_h2o
        """
        return self._parms.get("use_all_factor_levels")

    @use_all_factor_levels.setter
    def use_all_factor_levels(self, use_all_factor_levels):
        assert_is_type(use_all_factor_levels, None, bool)
        self._parms["use_all_factor_levels"] = use_all_factor_levels

    @property
    def max_runtime_secs(self):
        """
        Maximum allowed runtime in seconds for model training. Use 0 to disable.

        Type: ``float``, defaults to ``0.0``.

        :examples:

        >>> arrests = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/pca_test/USArrests.csv")
        >>> fit_h2o = H2OSingularValueDecompositionEstimator(nv=4,
        ...                                                  transform="standardize",
        ...                                                  max_runtime_secs=25)
        >>> fit_h2o.train(x=list(range(4)), training_frame=arrests)
        >>> fit_h2o
        """
        return self._parms.get("max_runtime_secs")

    @max_runtime_secs.setter
    def max_runtime_secs(self, max_runtime_secs):
        assert_is_type(max_runtime_secs, None, numeric)
        self._parms["max_runtime_secs"] = max_runtime_secs

    @property
    def export_checkpoints_dir(self):
        """
        Automatically export generated models to this directory.

        Type: ``str``.

        :examples:

        >>> import tempfile
        >>> from os import listdir
        >>> arrests = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/pca_test/USArrests.csv")
        >>> checkpoints_dir = tempfile.mkdtemp()
        >>> fit_h2o = H2OSingularValueDecompositionEstimator(export_checkpoints_dir=checkpoints_dir,
        ...                                                  seed=-5)
        >>> fit_h2o.train(x=list(range(4)), training_frame=arrests)
        >>> len(listdir(checkpoints_dir))
        """
        return self._parms.get("export_checkpoints_dir")

    @export_checkpoints_dir.setter
    def export_checkpoints_dir(self, export_checkpoints_dir):
        assert_is_type(export_checkpoints_dir, None, str)
        self._parms["export_checkpoints_dir"] = export_checkpoints_dir


    def init_for_pipeline(self):
        """
        Returns H2OSVD object which implements fit and transform method to be used in sklearn.Pipeline properly.
        All parameters defined in self.__params, should be input parameters in H2OSVD.__init__ method.

        :returns: H2OSVD object

        :examples:

        >>> from h2o.transforms.preprocessing import H2OScaler
        >>> from h2o.estimators import H2ORandomForestEstimator
        >>> from h2o.estimators import H2OSingularValueDecompositionEstimator
        >>> from sklearn.pipeline import Pipeline
        >>> arrests = h2o.import_file("https://s3.amazonaws.com/h2o-public-test-data/smalldata/pca_test/USArrests.csv")
        >>> pipe = Pipeline([("standardize", H2OScaler()),
        ...                  ("svd", H2OSingularValueDecompositionEstimator(nv=3).init_for_pipeline()),
        ...                  ("rf", H2ORandomForestEstimator(seed=42,ntrees=50))])
        >>> pipe.fit(arrests[1:], arrests[0])
        """
        import inspect
        from h2o.transforms.decomposition import H2OSVD
        # check which parameters can be passed to H2OSVD init
        var_names = list(dict(inspect.getmembers(H2OSVD.__init__.__code__))['co_varnames'])
        parameters = {k: v for k, v in self._parms.items() if k in var_names}
        return H2OSVD(**parameters)
