Placeholder Image

Subtitles section Play video

  • [MUSIC PLAYING]

  • YUFENG GUO: Machine learning is awesome,

  • except when it forces you to do advanced math.

  • The tools for machine learning have

  • gotten dramatically better, and training your own model

  • has never been easier.

  • We'll utilize our understanding of our dataset,

  • rather than an understanding of the raw mathematics,

  • to build a model that gets us insights.

  • Welcome to Cloud AI Adventures.

  • My name is Yufeng Guo.

  • On this show, we'll explore the art, science,

  • and tools of machine learning.

  • While machine learning might be a great conversation

  • topic at dinner parties, it's even more useful with code.

  • In this episode, we're going to train a simple classifier using

  • only a handful lines of code.

  • In fact, here's all the code that we'll look at today.

  • To train our classifier, we'll use

  • TensorFlow, Google's open source machine learning library.

  • TensorFlow has a pretty large API surface,

  • but the part we care about today is just the high level

  • APIs called estimators.

  • Estimators package up the training loop for us

  • so that we can train a model by configuring it, rather

  • than coding it by hand.

  • This takes away much of the boilerplate,

  • allowing us to think at a higher level of abstraction.

  • And this means we'll get to play with the interesting parts

  • of machine learning, and not get too bogged down in the details.

  • Since we've only covered linear models so far in the series,

  • we will stick with that here, and revisit this example

  • in the future to extend its capabilities.

  • So with that, let's dive right in and

  • go to our Jupiter notebook.

  • OK, so here we are in our Jupiter notebook.

  • And the first thing that we'll do

  • is import TensorFlow as tf and numpy as mp.

  • I like to print out the version number of TensorFlow

  • below to confirm which version I'm using.

  • This week, we'll be building a model

  • to distinguish between three different types of very

  • similar flowers.

  • I realize that this may be less interesting than the beer

  • and wine from the previous episode,

  • but these flowers are a bit more difficult to distinguish,

  • making this a more interesting challenge.

  • In particular, we'll be classifying different species

  • of iris flowers.

  • Now, I'm not sure I could pick out an iris flower from a field

  • of roses, but our model is aiming to distinguish iris

  • setosa, iris versicolour, and iris virginica.

  • We have a dataset of measurements

  • of the height and width of these flowers as petals and sepals.

  • These four columns will serve as our features.

  • So let's load our dataset in using TensorFlow's Load

  • CSV with Header function.

  • The data or features are presented as floating point

  • numbers, and the label for each row of data or target

  • is recorded as an integer--

  • 0, 1, or 2-- corresponding to our three species of flowers.

  • Now I've printed out the results for our loading,

  • and we can see that we are now able to access the trained

  • data and the associated labels or targets

  • using named attributes.

  • Next, we'll build the model.

  • To do this, we'll first set up the feature columns.

  • Feature columns define the types of data coming into the model.

  • We are using a four-dimensional feature column

  • to represent our features, and calling them flower features.

  • Building our model using estimators is super simple.

  • Using tf.estimators.LinearClassifier,

  • we can instantiate the model by passing in the future columns

  • we just created.

  • The number of different outputs that the model predicts--

  • in this case, 3--

  • and a directory to store the model's training

  • progress and the output files.

  • This allows TensorFlow to pick up training

  • later on from where it left off, if needed.

  • This classifier object will keep track of state for us.

  • And we are now almost ready to move on to the training.

  • There is just one final piece to connect

  • our model to the training data, and that is the input function.

  • The job of the input function is to create

  • the TensorFlow operations that generate data for the model.

  • So we go from raw data to the input function,

  • which passes that data that is then mapped by the feature

  • columns to go into the model.

  • Notice that we use the same name for the features as we

  • did in defining the feature column.

  • This is how the data is associated.

  • Now it's time to run our training.

  • To train our model, we'll just run classifier.train

  • with the input function passed in as an argument.

  • This is how we connect our dataset to the model.

  • The train function handles the training loop and iterates

  • over the dataset, improving its performance with each step.

  • And just like that, we've completed 1,000 training steps.

  • Our dataset's not huge, so this completed rather quickly.

  • Now it's time to evaluate our results.

  • We can do this using the same classifier object from before,

  • as it holds the trained state of the model.

  • To determine how good our model is,

  • we run classifier.evaluate and pass in our test dataset.

  • Then we can extract the accuracy from the metrics

  • that are returned.

  • 96.6%.

  • OK.

  • Let's pause here and review what we've achieved so far.

  • The estimator's API has given us a nice workflow

  • of getting our raw data and passing it through an input

  • function, setting up our feature columns and model structure,

  • running our training, and finally,

  • running our evaluation.

  • This easy-to-understand framework

  • allows us to think about our data and its properties,

  • rather than the underlying math, which is a great place to be.

  • Today, we looked at a very simple version

  • of TensorFlow's high level API using a canned estimator.

  • In future episodes, we'll look at how

  • to augment this model with more details, use more complex data,

  • and even more advanced features.

  • Thanks for watching that episode of Cloud AI Adventures.

  • You can catch the whole series here.

  • And if you have any thoughts and comments,

  • feel free to leave them down below.

[MUSIC PLAYING]

Subtitles and vocabulary

Click the word to look it up Click the word to find further inforamtion about it