Added an XGBoost example, from training on a notebook to deploying on Algorithmia

Author: aslisabanci

xgboost_notebook_to_algorithmia/.DS_Store

@@ -0,0 +1,22 @@
+# Developing an XGBoost model on a Jupyter notebook and deploying to Algorithmia
+
+This Jupyter notebook to Algorithmia example is to demonstrate how you can programmatically create an algorithm on [Algorithmia](https://algorithmia.com), train a model and deploy it for serving, all from within your Jupyter notebook.
+
+Step by step, we will:
+
+- Create an algorithm on Algorithmia
+- Clone the algorithm's repository on our local machine, so that we develop it locally
+- Create the basic algorithm script and the dependencies file. We will code our script in advance, assuming that our model will be sitting on a remote path on - Algorithmia and our script will load the model from there. We will then make these assumptions true!
+- Commit and push these files to Algorithmia and get our Algorithm's container built
+- Load our training data
+- Preprocess the data
+- Setup an XGBoost model and do a mini hyperparameter search
+- Fit the data on our model
+- Get the predictions
+- Check the accuracy
+- Repeat the model development iterations until we are happy with our model :)
+
+And finally, once we are happy with the model performance, we will upload it to Algorithmia and have it up and ready to serve our upcoming prediction requests!
+
+
+You can also check out the built algorithm at https://algorithmia.com/algorithms/asli/xgboost_basic_sentiment_analysis and see the final product in action.

xgboost_notebook_to_algorithmia/README.md

@@ -0,0 +1,88 @@
+import Algorithmia
+import urllib.parse
+from git import Git, Repo, remote
+from retry import retry
+
+
+class Progress(remote.RemoteProgress):
+    def line_dropped(self, line):
+        print(line)
+
+    def update(self, *args):
+        print(self._cur_line)
+
+
+class AlgorithmiaUtils:
+    def __init__(self, api_key, username, algo_name, local_dir):
+        self.api_key = api_key
+        self.username = username
+        self.algo_name = algo_name
+        self.local_dir = local_dir
+
+        self.algo_namespace = f"{self.username}/{self.algo_name}"
+        self.algo_script_path = "{}/{}/src/{}.py".format(
+            self.local_dir, algo_name, algo_name
+        )
+        self.dependency_file_path = "{}/{}/{}".format(
+            self.local_dir, algo_name, "requirements.txt"
+        )
+
+        self.algo_client = Algorithmia.client(self.api_key)
+
+    def create_algorithm(self):
+        details = {
+            "summary": "ALGO_SUMMARY",
+            "label": "ALGO_LABEL",
+            "tagline": "ALGO_TAGLINE",
+        }
+        settings = {
+            "source_visibility": "closed",
+            "package_set": "python37",
+            "license": "apl",
+            "network_access": "full",
+            "pipeline_enabled": True,
+        }
+        self.algo_client.algo(self.algo_namespace).create(details, settings)
+
+    def clone_algorithm_repo(self):
+        # Encoding the API key, so we can use it in the git URL
+        encoded_api_key = urllib.parse.quote_plus(self.api_key)
+
+        algo_repo = "https://{}:{}@git.algorithmia.com/git/{}/{}.git".format(
+            self.username, encoded_api_key, self.username, self.algo_name
+        )
+        p = Progress()
+        self.repo = Repo.clone_from(
+            algo_repo, "{}/{}".format(self.local_dir, self.algo_name), progress=p
+        )
+
+    def push_algo_script_with_dependencies(self):
+        if not self.repo:
+            self.repo = Repo("{}/{}".format(local_dir, algo_name))
+        files = ["src/{}.py".format(self.algo_name), "requirements.txt"]
+        self.repo.index.add(files)
+        self.repo.index.commit("Updated algorithm files")
+        p = Progress()
+        self.repo.remote(name="origin").push(progress=p)
+
+    def upload_model_to_algorithmia(
+        self, local_path, algorithmia_data_path, model_name
+    ):
+        if not self.algo_client.dir(algorithmia_data_path).exists():
+            self.algo_client.dir(algorithmia_data_path).create()
+        algorithmia_path = "{}/{}".format(algorithmia_data_path, model_name)
+        result = self.algo_client.file(algorithmia_path).putFile(local_path)
+        # TODO: Act on the result object, have a return value
+
+    # Call algorithm until the algo hash endpoint becomes available, up to 10 seconds
+    @retry(Algorithmia.errors.AlgorithmException, tries=10, delay=1)
+    def call_latest_algo_version(self, input):
+        latest_algo_hash = (
+            self.algo_client.algo(self.algo_namespace).info().version_info.git_hash
+        )
+        algo = self.algo_client.algo(
+            "{}/{}".format(self.algo_namespace, latest_algo_hash)
+        )
+        algo.set_options(timeout=60, stdout=False)
+        algo_pipe_result = algo.pipe(input)
+        return algo_pipe_result