Address comments.

Author: lukmis

src/sagemaker/amazon/amazon_estimator.py

@@ -31,21 +31,17 @@ class AmazonAlgorithmEstimatorBase(EstimatorBase):
     feature_dim = hp('feature_dim', (validation.isint, validation.gt(0)))
     mini_batch_size = hp('mini_batch_size', (validation.isint, validation.gt(0)))
 
-    def __init__(self, role, train_instance_count, train_instance_type,
-                 default_mini_batch_size=None, data_location=None, **kwargs):
+    def __init__(self, role, train_instance_count, train_instance_type, data_location=None, **kwargs):
         """Initialize an AmazonAlgorithmEstimatorBase.
 
         Args:
-            default_mini_batch_size (int): Default size of mini-batch used for training set for algorithms that
-                require this parameter.
             data_location (str or None): The s3 prefix to upload RecordSet objects to, expressed as an
                 S3 url. For example "s3://example-bucket/some-key-prefix/". Objects will be
                 saved in a unique sub-directory of the specified location. If None, a default
                 data location will be used."""
         super(AmazonAlgorithmEstimatorBase, self).__init__(role, train_instance_count, train_instance_type,
                                                            **kwargs)
 
-        self.default_mini_batch_size = default_mini_batch_size
         default_location = "s3://{}/sagemaker-record-sets/".format(self.sagemaker_session.default_bucket())
         data_location = data_location or default_location
         self.data_location = data_location
@@ -89,8 +85,8 @@ def fit(self, records, mini_batch_size=None, **kwargs):
             mini_batch_size (int or None): The size of each mini-batch to use when training. If None, a
                 default value will be used.
         """
-        self.mini_batch_size = mini_batch_size or self.default_mini_batch_size
         self.feature_dim = records.feature_dim
+        self.mini_batch_size = mini_batch_size
 
         data = {records.channel: s3_input(records.s3_data, distribution='ShardedByS3Key',
                                           s3_data_type=records.s3_data_type)}

src/sagemaker/amazon/factorization_machines.py

@@ -13,7 +13,7 @@
 from sagemaker.amazon.amazon_estimator import AmazonAlgorithmEstimatorBase, registry
 from sagemaker.amazon.common import numpy_to_record_serializer, record_deserializer
 from sagemaker.amazon.hyperparameter import Hyperparameter as hp  # noqa
-from sagemaker.amazon.validation import gt, isin, isint, ge, isfloat
+from sagemaker.amazon.validation import gt, isin, isint, ge, isnumber
 from sagemaker.predictor import RealTimePredictor
 from sagemaker.model import Model
 from sagemaker.session import Session
@@ -27,30 +27,30 @@ class FactorizationMachines(AmazonAlgorithmEstimatorBase):
     predictor_type = hp('predictor_type', isin('binary_classifier', 'regressor'),
                         'Value "binary_classifier" or "regressor"')
     epochs = hp('epochs', (gt(0), isint), "An integer greater than 0")
-    clip_gradient = hp('clip_gradient', isfloat, "A float value")
-    eps = hp('eps', isfloat, "A float value")
-    rescale_grad = hp('rescale_grad', isfloat, "A float value")
-    bias_lr = hp('bias_lr', (ge(0), isfloat), "A non-negative float")
-    linear_lr = hp('linear_lr', (ge(0), isfloat), "A non-negative float")
-    factors_lr = hp('factors_lr', (ge(0), isfloat), "A non-negative float")
-    bias_wd = hp('bias_wd', (ge(0), isfloat), "A non-negative float")
-    linear_wd = hp('linear_wd', (ge(0), isfloat), "A non-negative float")
-    factors_wd = hp('factors_wd', (ge(0), isfloat), "A non-negative float")
+    clip_gradient = hp('clip_gradient', isnumber, "A float value")
+    eps = hp('eps', isnumber, "A float value")
+    rescale_grad = hp('rescale_grad', isnumber, "A float value")
+    bias_lr = hp('bias_lr', (ge(0), isnumber), "A non-negative float")
+    linear_lr = hp('linear_lr', (ge(0), isnumber), "A non-negative float")
+    factors_lr = hp('factors_lr', (ge(0), isnumber), "A non-negative float")
+    bias_wd = hp('bias_wd', (ge(0), isnumber), "A non-negative float")
+    linear_wd = hp('linear_wd', (ge(0), isnumber), "A non-negative float")
+    factors_wd = hp('factors_wd', (ge(0), isnumber), "A non-negative float")
     bias_init_method = hp('bias_init_method', isin('normal', 'uniform', 'constant'),
                           'Value "normal", "uniform" or "constant"')
-    bias_init_scale = hp('bias_init_scale', (ge(0), isfloat), "A non-negative float")
-    bias_init_sigma = hp('bias_init_sigma', (ge(0), isfloat), "A non-negative float")
-    bias_init_value = hp('bias_init_value', isfloat, "A float value")
+    bias_init_scale = hp('bias_init_scale', (ge(0), isnumber), "A non-negative float")
+    bias_init_sigma = hp('bias_init_sigma', (ge(0), isnumber), "A non-negative float")
+    bias_init_value = hp('bias_init_value', isnumber, "A float value")
     linear_init_method = hp('linear_init_method', isin('normal', 'uniform', 'constant'),
                             'Value "normal", "uniform" or "constant"')
-    linear_init_scale = hp('linear_init_scale', (ge(0), isfloat), "A non-negative float")
-    linear_init_sigma = hp('linear_init_sigma', (ge(0), isfloat), "A non-negative float")
-    linear_init_value = hp('linear_init_value', isfloat, "A float value")
+    linear_init_scale = hp('linear_init_scale', (ge(0), isnumber), "A non-negative float")
+    linear_init_sigma = hp('linear_init_sigma', (ge(0), isnumber), "A non-negative float")
+    linear_init_value = hp('linear_init_value', isnumber, "A float value")
     factors_init_method = hp('factors_init_method', isin('normal', 'uniform', 'constant'),
                              'Value "normal", "uniform" or "constant"')
-    factors_init_scale = hp('factors_init_scale', (ge(0), isfloat), "A non-negative float")
-    factors_init_sigma = hp('factors_init_sigma', (ge(0), isfloat), "A non-negative float")
-    factors_init_value = hp('factors_init_value', isfloat, "A float value")
+    factors_init_scale = hp('factors_init_scale', (ge(0), isnumber), "A non-negative float")
+    factors_init_sigma = hp('factors_init_sigma', (ge(0), isnumber), "A non-negative float")
+    factors_init_value = hp('factors_init_value', isnumber, "A float value")
 
     def __init__(self, role, train_instance_count, train_instance_type,
                  num_factors, predictor_type,

src/sagemaker/amazon/kmeans.py

@@ -33,8 +33,8 @@ class KMeans(AmazonAlgorithmEstimatorBase):
     epochs = hp('epochs', (gt(0), isint), 'An integer greater-than 0')
     center_factor = hp('extra_center_factor', (gt(0), isint), 'An integer greater-than 0')
 
-    def __init__(self, role, train_instance_count, train_instance_type, k, default_mini_batch_size=5000,
-                 init_method=None, max_iterations=None, tol=None, num_trials=None, local_init_method=None,
+    def __init__(self, role, train_instance_count, train_instance_type, k, init_method=None,
+                 max_iterations=None, tol=None, num_trials=None, local_init_method=None,
                  half_life_time_size=None, epochs=None, center_factor=None, **kwargs):
         """
         A k-means clustering :class:`~sagemaker.amazon.AmazonAlgorithmEstimatorBase`. Finds k clusters of data in an
@@ -67,7 +67,6 @@ def __init__(self, role, train_instance_count, train_instance_type, k, default_m
             train_instance_count (int): Number of Amazon EC2 instances to use for training.
             train_instance_type (str): Type of EC2 instance to use for training, for example, 'ml.c4.xlarge'.
             k (int): The number of clusters to produce.
-            default_mini_batch_size (int): Default size of mini-batch used for training.
             init_method (str): How to initialize cluster locations. One of 'random' or 'kmeans++'.
             max_iterations (int): Maximum iterations for Lloyds EM procedure in the local kmeans used in finalize stage.
             tol (int): Tolerance for change in ssd for early stopping in local kmeans.
@@ -84,8 +83,7 @@ def __init__(self, role, train_instance_count, train_instance_type, k, default_m
                 reduce the number of centers to ``k`` when finalizing
             **kwargs: base class keyword argument values.
         """
-        super(KMeans, self).__init__(role, train_instance_count, train_instance_type,
-                                     default_mini_batch_size, **kwargs)
+        super(KMeans, self).__init__(role, train_instance_count, train_instance_type, **kwargs)
         self.k = k
         self.init_method = init_method
         self.max_iterations = max_iterations
@@ -101,6 +99,9 @@ def create_model(self):
         s3 model data produced by this Estimator."""
         return KMeansModel(self.model_data, self.role, self.sagemaker_session)
 
+    def fit(self, records, mini_batch_size=5000, **kwargs):
+        super(KMeans, self).fit(records, mini_batch_size, **kwargs)
+
     def hyperparameters(self):
         """Return the SageMaker hyperparameters for training this KMeans Estimator"""
         hp = dict(force_dense='True')  # KMeans requires this hp to fit on Record objects

src/sagemaker/amazon/linear_learner.py

@@ -23,6 +23,8 @@ class LinearLearner(AmazonAlgorithmEstimatorBase):
 
     repo = 'linear-learner:1'
 
+    DEFAULT_MINI_BATCH_SIZE = 1000
+
     binary_classifier_model_selection_criteria = hp('binary_classifier_model_selection_criteria',
                                                     isin('accuracy', 'f1', 'precision_at_target_recall',
                                                          'recall_at_target_precision', 'cross_entropy_loss'))
@@ -60,7 +62,7 @@ class LinearLearner(AmazonAlgorithmEstimatorBase):
     unbias_label = hp('unbias_label', isbool, 'A boolean')
     num_point_for_scalar = hp('num_point_for_scalar', (isint, gt(0)), 'An integer greater-than 0')
 
-    def __init__(self, role, train_instance_count, train_instance_type, predictor_type,
+    def __init__(self, role, train_instance_count, train_instance_type, predictor_type='binary_classifier',
                  binary_classifier_model_selection_criteria=None, target_recall=None, target_precision=None,
                  positive_example_weight_mult=None, epochs=None, use_bias=None, num_models=None,
                  num_calibration_samples=None, init_method=None, init_scale=None, init_sigma=None, init_bias=None,
@@ -191,6 +193,13 @@ def create_model(self):
 
         return LinearLearnerModel(self, self.model_data, self.role, self.sagemaker_session)
 
+    def fit(self, records, mini_batch_size=None, **kwargs):
+        # mini_batch_size can't be greater than number of records or training job fails
+        default_mini_batch_size = min(self.DEFAULT_MINI_BATCH_SIZE,
+                                      max(1, int(records.num_records / self.train_instance_count)))
+        use_mini_batch_size = mini_batch_size or default_mini_batch_size
+        super(LinearLearner, self).fit(records, use_mini_batch_size, **kwargs)
+
 
 class LinearLearnerPredictor(RealTimePredictor):
     """Performs binary-classification or regression prediction from input vectors.

src/sagemaker/amazon/pca.py

@@ -22,6 +22,8 @@ class PCA(AmazonAlgorithmEstimatorBase):
 
     repo = 'pca:1'
 
+    DEFAULT_MINI_BATCH_SIZE = 500
+
     num_components = hp(name='num_components', validate=lambda x: x > 0 and isinstance(x, int),
                         validation_message='Value must be an integer greater than zero')
     algorithm_mode = hp(name='algorithm_mode', validate=lambda x: x in ['regular', 'stable', 'randomized'],
@@ -31,7 +33,7 @@ class PCA(AmazonAlgorithmEstimatorBase):
     extra_components = hp(name='extra_components', validate=lambda x: x >= 0 and isinstance(x, int),
                           validation_message="Value must be an integer greater than or equal to 0")
 
-    def __init__(self, role, train_instance_count, train_instance_type, num_components, default_mini_batch_size,
+    def __init__(self, role, train_instance_count, train_instance_type, num_components,
                  algorithm_mode=None, subtract_mean=None, extra_components=None, **kwargs):
         """A Principal Components Analysis (PCA) :class:`~sagemaker.amazon.amazon_estimator.AmazonAlgorithmEstimatorBase`.
 
@@ -66,7 +68,6 @@ def __init__(self, role, train_instance_count, train_instance_type, num_componen
             train_instance_count (int): Number of Amazon EC2 instances to use for training.
             train_instance_type (str): Type of EC2 instance to use for training, for example, 'ml.c4.xlarge'.
             num_components(int): The number of principal components. Must be greater than zero.
-            default_mini_batch_size (int): Default size of mini-batch used for training.
             algorithm_mode (str): Mode for computing the principal components. One of 'regular', 'stable' or
                 'randomized'.
             subtract_mean (bool): Whether the data should be unbiased both during train and at inference.
@@ -75,8 +76,7 @@ def __init__(self, role, train_instance_count, train_instance_type, num_componen
                 to the maximum of 10 and num_components will be used. Valid for randomized mode only.
             **kwargs: base class keyword argument values.
         """
-        super(PCA, self).__init__(role, train_instance_count, train_instance_type,
-                                  default_mini_batch_size, **kwargs)
+        super(PCA, self).__init__(role, train_instance_count, train_instance_type, **kwargs)
         self.num_components = num_components
         self.algorithm_mode = algorithm_mode
         self.subtract_mean = subtract_mean
@@ -88,6 +88,13 @@ def create_model(self):
 
         return PCAModel(self.model_data, self.role, sagemaker_session=self.sagemaker_session)
 
+    def fit(self, records, mini_batch_size=None, **kwargs):
+        # mini_batch_size is a required parameter
+        default_mini_batch_size = min(self.DEFAULT_MINI_BATCH_SIZE,
+                                      max(1, int(records.num_records / self.train_instance_count)))
+        use_mini_batch_size = mini_batch_size or default_mini_batch_size
+        super(PCA, self).fit(records, use_mini_batch_size, **kwargs)
+
 
 class PCAPredictor(RealTimePredictor):
     """Transforms input vectors to lower-dimesional representations.

src/sagemaker/amazon/validation.py

@@ -46,4 +46,3 @@ def validate(value):
 isint = istype(int)
 isbool = istype(bool)
 isnumber = istype(numbers.Number)  # noqa
-isfloat = istype(float)

tests/integ/test_factorization_machines.py

@@ -38,7 +38,6 @@ def test_factorization_machines():
         fm = FactorizationMachines(role='SageMakerRole', train_instance_count=1,
                                    train_instance_type='ml.c4.xlarge',
                                    num_factors=10, predictor_type='regressor',
-                                   default_mini_batch_size=100,
                                    epochs=2, clip_gradient=1e2, eps=0.001, rescale_grad=1.0/100,
                                    sagemaker_session=sagemaker_session, base_job_name='test-fm')
 

tests/integ/test_linear_learner.py

@@ -39,8 +39,8 @@ def test_linear_learner():
         train_set[1][100:200] = 0
         train_set = train_set[0], train_set[1].astype(np.dtype('float32'))
 
-        ll = LinearLearner('SageMakerRole', 1, 'ml.c4.2xlarge', predictor_type='binary_classifier',
-                           base_job_name='test-linear-learner', sagemaker_session=sagemaker_session)
+        ll = LinearLearner('SageMakerRole', 1, 'ml.c4.2xlarge', base_job_name='test-linear-learner',
+                           sagemaker_session=sagemaker_session)
         ll.binary_classifier_model_selection_criteria = 'accuracy'
         ll.target_reacall = 0.5
         ll.target_precision = 0.5
@@ -71,7 +71,7 @@ def test_linear_learner():
         ll.unbias_data = True
         ll.unbias_label = False
         ll.num_point_for_scala = 10000
-        ll.fit(ll.record_set(train_set[0][:200], train_set[1][:200]), mini_batch_size=100)
+        ll.fit(ll.record_set(train_set[0][:200], train_set[1][:200]))
 
     endpoint_name = name_from_base('linear-learner')
     with timeout_and_delete_endpoint_by_name(endpoint_name, sagemaker_session, minutes=20):

tests/integ/test_pca.py

@@ -35,7 +35,7 @@ def test_pca():
             train_set, _, _ = pickle.load(f, **pickle_args)
 
         pca = sagemaker.amazon.pca.PCA(role='SageMakerRole', train_instance_count=1,
-                                       train_instance_type='ml.m4.xlarge', default_mini_batch_size=500,
+                                       train_instance_type='ml.m4.xlarge',
                                        num_components=48, sagemaker_session=sagemaker_session, base_job_name='test-pca')
 
         pca.algorithm_mode = 'randomized'