Hide Rafiki-internal advisor methods from client; fix typos in docs

Author: nginyc

rafiki/client/client.py

@@ -168,7 +168,7 @@ def create_model(self, name, task, model_file_path, model_class, dependencies={}
         :param str name: Name of the model, which must be unique across all models added by the current user 
         :param str task: Task associated with the model, where the model must adhere to the specification of the task
         :param str model_file_path: Path to a single Python file that contains the definition for the model class
-        :param obj model_class: The name of the model class inside the Python file. This class should implement :class:`rafiki.model.BaseModel`
+        :param str model_class: The name of the model class inside the Python file. This class should implement :class:`rafiki.model.BaseModel`
         :param dependencies: List of dependencies & their versions
         :type dependencies: dict[str, str]
         :param access_right: Model access right
@@ -188,7 +188,7 @@ def create_model(self, name, task, model_file_path, model_class, dependencies={}
         ``<dependency_name>`` corresponds to the name of the Python Package Index (PyPI) package (e.g. ``tensorflow``)
         and ``<dependency_version>`` corresponds to the version of the PyPI package (e.g. ``1.12.0``). These dependencies 
         will be lazily installed on top of the worker's Docker image before the submitted model's code is executed.
-        If the model is to be run on GPU, Rafiki would map dependencies to their GPU-supported versions, if required. 
+        If the model is to be run on GPU, Rafiki would map dependencies to their GPU-supported versions, if supported. 
         For example, ``{ 'tensorflow': '1.12.0' }`` will be installed as ``{ 'tensorflow-gpu': '1.12.0' }``.
         Rafiki could also parse specific dependency names to install certain non-PyPI packages. 
         For example, ``{ 'singa': '1.1.1' }`` will be installed as ``singa-cpu=1.1.1`` or ``singa-gpu=1.1.1`` using ``conda``.
@@ -583,7 +583,7 @@ def stop_inference_job(self, app, app_version=-1):
     # Advisors
     ####################################
 
-    def create_advisor(self, knob_config_str, advisor_id=None):
+    def _create_advisor(self, knob_config_str, advisor_id=None):
         '''
         Creates a Rafiki advisor. If `advisor_id` is passed, it will create an advisor
         of that ID, or do nothing if an advisor of that ID has already been created.
@@ -600,7 +600,7 @@ def create_advisor(self, knob_config_str, advisor_id=None):
                             })
         return data
 
-    def generate_proposal(self, advisor_id):
+    def _generate_proposal(self, advisor_id):
         '''
         Generate a proposal of knobs from an advisor.
 
@@ -611,7 +611,7 @@ def generate_proposal(self, advisor_id):
         data = self._post('/advisors/{}/propose'.format(advisor_id), target='advisor')
         return data
 
-    def feedback_to_advisor(self, advisor_id, knobs, score):
+    def _feedback_to_advisor(self, advisor_id, knobs, score):
         '''
         Feedbacks to the advisor on the score of a set of knobs.
         Additionally returns another proposal of knobs after ingesting feedback.
@@ -629,7 +629,7 @@ def feedback_to_advisor(self, advisor_id, knobs, score):
                         })
         return data
 
-    def delete_advisor(self, advisor_id):
+    def _delete_advisor(self, advisor_id):
         '''
         Deletes a Rafiki advisor.
 

rafiki/model/knob.py

@@ -109,7 +109,7 @@ def _validate_value(value):
 
 class IntegerKnob(BaseKnob):
     '''
-    Knob type epresenting `any` ``int`` value within a specific interval [``value_min``, ``value_max``].
+    Knob type representing `any` ``int`` value within a specific interval [``value_min``, ``value_max``].
     ``is_exp`` specifies whether the knob value should be scaled exponentially.
     '''
 

rafiki/model/model.py

@@ -95,7 +95,7 @@ def predict(self, queries):
     @abc.abstractmethod
     def dump_parameters(self):
         '''
-        Return a dictionary of model parameters that fully define this model instance's trained state. 
+        Return a dictionary of model parameters that fully defines this model instance's trained state. 
         This dictionary should be serializable by the Python's ``pickle`` module.
         This will be used for trained model serialization within Rafiki.
         This will be called only when model is *trained*.
@@ -135,9 +135,10 @@ def test_model_class(model_file_path, model_class, task, dependencies, \
     It is assumed that all of the model's dependencies have been installed in the current Python environment. 
 
     :param str model_file_path: Path to a single Python file that contains the definition for the model class
-    :param obj model_class: The name of the model class inside the Python file. This class should implement :class:`rafiki.model.BaseModel`
+    :param type model_class: The name of the model class inside the Python file. This class should implement :class:`rafiki.model.BaseModel`
     :param str task: Task type of model
-    :param dict[str, str] dependencies: Model's dependencies
+    :param dependencies: Model's dependencies
+    :type dependencies: dict[str, str]
     :param str train_dataset_uri: URI of the train dataset for testing the training of model
     :param str test_dataset_uri: URI of the test dataset for testing the evaluating of model
     :param list[any] queries: List of queries for testing predictions with the trained model

rafiki/worker/train.py

@@ -187,13 +187,13 @@ def _train_and_evaluate_model(self, clazz, knobs, train_dataset_uri, \
 
     # Gets proposal of a set of knob values from advisor
     def _get_proposal_from_advisor(self, advisor_id):
-        res = self._get_client().generate_proposal(advisor_id)
+        res = self._get_client()._generate_proposal(advisor_id)
         knobs = res['knobs']
         return knobs
 
     # Feedback result of knobs to advisor
     def _feedback_to_advisor(self, advisor_id, knobs, score):
-        self._get_client().feedback_to_advisor(advisor_id, knobs, score)
+        self._get_client()._feedback_to_advisor(advisor_id, knobs, score)
 
     def _stop_sub_train_job(self):
         logger.warn('Stopping sub train job...')
@@ -210,14 +210,14 @@ def _create_advisor(self, clazz):
         knob_config_str = serialize_knob_config(knob_config)
 
         # Create advisor associated with worker
-        res = self._get_client().create_advisor(knob_config_str, advisor_id=self._service_id)
+        res = self._get_client()._create_advisor(knob_config_str, advisor_id=self._service_id)
         advisor_id = res['id']
         return advisor_id
 
     # Delete advisor
     def _delete_advisor(self, advisor_id):
         try:
-            self._get_client().delete_advisor(advisor_id)
+            self._get_client()._delete_advisor(advisor_id)
         except Exception:
             # Throw just a warning - not critical for advisor to be deleted
             logger.warning('Error while deleting advisor:')