YUFENG GUO: With over 500 sessions at NEXT 2018,
it's understandable that you couldn't get to them all.
So if you didn't see Machine Learning with Scikit-Learn
and XGBoost on Google Cloud Platform,
then stay tuned because here's the rewind.
[MUSIC PLAYING]
I really enjoyed this session because it
talks about using Scikit-Learn and XGBoost
in some unexpected ways.
From trading in clusters for large single-node virtual
machines to using managed services to do
the scaling for you, this talk was packed with demos, code,
and great tips and tricks.
Plus, you get to hear from David Cournapeau,
the creator of Scikit-Learn.
What a treat.
Let's dive in.
Scikit-Learn and XGBoost are great libraries.
And unlike TensorFlow, they're not
used for deep learning but for a class of problems which
are very common in businesses.
You may find that XGBoost or Scikit-Learn can give you
better results with less effort.
We can view the machine learning workflow through the simplified
lens of three stages--
preprocessing, training, and prediction.
Preprocessing is a stage of machine learning
in which the raw data is made ready for the modeling.
This leads us to training, which is
the process in which the model is
tuned to predict a target variable from labeled input
data.
And finally, prediction is then that process
of predicting results for new unlabeled input.
There are many challenges when it comes to preprocessing,
and for unstructured data, Scikit-Learn
can sometimes fall short.
Here, the machine learning APIs can prove pretty helpful.
The full talk shows a couple of examples of this,
and there's one in particular where the Natural Language
API is used to tokenize Japanese text.
And this solves a problem that's not
suitable for Scikit-Learn's preprocessing modules.
It's a really interesting example.
The second stage of the ML workflow is the train.
And if you know that icon, it's the Google Compute Engine icon.
So you might be thinking, are we really
going to talk about virtual machines in a machine learning
talk.
The answer is a resounding yes.
Nowadays, virtual machines have gotten way bigger.
Compute Engine allows you to configure up machines with up
to four terabytes of memory-- not disk--
memory.
And it's even got the compute power
to pair with it so you can do something with that memory.
And on the software side, libraries like Dask
allow you to parallelize your work in pandas
without needing to have a cluster
of multiple machines set up.
Even at big companies, the "large" datasets being used,
they end up typically being less than 14 gigabytes.
And even for a truly large data sets,
you can often just take a subset of that data
for experimentation.
So don't underestimate the cost of losing out on what
David calls "data agility."
The full talk offers up a great resource
for helping you take advantage of this kind of burst training
with a script that sets up a machine, run your job,
and then cleans it all up afterwards.
Definitely check that out if you're
looking to try out this mode of operating.
The final portion of the talk covers Cloud ML Engine.
If your service relies on predictions or if you regularly
need to retrain your model on new data,
Cloud ML Engine can help and Scikit-Learn and XGBoost
are also now supported in addition to TensorFlow.
And it's for both training and prediction.
So you don't need to use different workflows
for different machine learning libraries.
The full talk has a pretty slick top-to-bottom demo
of preprocessing the data, training a Scikit-Learn model,
and then exporting that model and finally deploying it
to Cloud ML Engine, all in one notebook.
If you'd like this video, give it a thumbs up,
and I've included the link to the full talk
in the description below.
And don't forget to subscribe to the Google Cloud YouTube
channel for more great content.
I'll see you on the next "Rewind."
[MUSIC PLAYING]