{"id":2437,"date":"2016-04-06T15:20:30","date_gmt":"2016-04-06T15:20:30","guid":{"rendered":"https:\/\/www.www.sharpsightlabs.com\/?p=2437"},"modified":"2021-07-23T21:45:42","modified_gmt":"2021-07-24T02:45:42","slug":"quick-introduction-machine-learning-r-caret","status":"publish","type":"post","link":"https:\/\/www.sharpsightlabs.com\/blog\/quick-introduction-machine-learning-r-caret\/","title":{"rendered":"A quick introduction to machine learning in R with caret"},"content":{"rendered":"

If you’ve been using R for a while, and you’ve been working with basic data visualization and data exploration techniques, the next logical step is to start learning some machine learning.<\/p>\n

To help you begin learning about machine learning in R, I’m going to introduce you to an R package: the caret package. We’ll build a very simple machine learning model as a way to learn some of caret’s basic syntax and functionality. <\/p>\n

But before diving into caret, let’s quickly discuss what machine learning is and why we use it.<\/p>\n

What is machine learning?<\/h3>\n

Machine learning is the study of data-driven, computational methods for making inferences and predictions. <\/p>\n

Without going into extreme depth here, let’s unpack that by looking at an example.<\/p>\n

A simple example<\/h4>\n

Imagine that you want to understand the relationship between car weight and car fuel efficiency (I.e., miles per gallon); how is fuel efficiency effected by a car’s weight?<\/p>\n

To answer this question, you could obtain a dataset with several different car models, and attempt to identify a relationship between weight (which we’ll call wt<\/inline_code>) and miles per gallon (which we’ll call mpg<\/inline_code>).<\/p>\n

A good starting point would be to simply plot the data, so first, we’ll create a scatterplot using R’s ggplot:<\/p>\n

\r\nrequire(ggplot2)\r\n\r\nggplot(data = mtcars, aes(x = wt, y = mpg)) +\r\n  geom_point()\r\n\r\n<\/pre>\n
 
\n\"2016-04-06_quick-intro-to-machine-learning-in-R-with-Caret__scatter1\"<\/p>\n
Just examining the data visually, it’s pretty clear that there’s some relationship. But if we want to make more precise claims about the relationship between wt<\/inline_code> and mpg<\/inline_code>, we need to specify this relationship mathematically<\/i>.  So, as we press forward in our analysis, we’ll make the assumption that this relationship can be described mathematically; more precisely, we’ll assume that this relationship can be described by some mathematical function, \"f(x)\".  In the case of the above example, we’ll be making the assumption that “miles per gallon” can be described as a function of “car weight”.<\/p>\n
Assuming this type of mathematical relationship, machine learning provides a set of methods for identifying that relationship.  Said differently, machine learning provides a set of computational methods that accept data observations as inputs, and subsequently estimate that mathematical function, \"f(x)\"; machine learning methods learn<\/i> the relationship by being trained<\/i> with an input dataset.<\/p>\n
Ultimately, once we have this mathematical function (a model), we can use that model to make predictions and inferences.<\/p>\n
How much math you really<\/i> need to know<\/h3>\n
What I just wrote in the last few paragraphs about “estimating functions” and “mathematical relationships” might cause you to ask a question: “how much math do I need to know to do machine learning?”<\/p>\n
Ok, here is some good news: to implement basic machine learning techniques, you don’t need to know much math.  <\/p>\n
To be clear, there is quite a bit of math involved in machine learning, but most of that math is taken care of for you.  What I mean, is that for the most part, R libraries and functions perform the mathematical calculations for you.  You just need to know which functions to use, and when to use them.  <\/p>\n
Here’s an analogy: if you were a carpenter, you wouldn’t need to build your own power tools.  You wouldn’t need to build your own drill and power saw.  Therefore, you wouldn’t need to understand the mathematics, physics, and electrical engineering principles that would be required to construct those tools from scratch.  You could just go and buy them “off the shelf.”  To be clear, you’d still need to learn how to use<\/i> those tools, but you wouldn’t need a deep understanding of math and electrical engineering to operate them.<\/p>\n
When you’re first getting started with machine learning, the situation is very similar: you can learn to use some of the tools, without knowing the deep mathematics that makes those tools work.<\/p>\n
Having said that, the above analogy is somewhat imperfect.  At some point, as you progress to more advanced topics, it will be very beneficial to know the underlying mathematics.  My argument, however, is that in the beginning, you can still be productive without a deep understanding of calculus, linear algebra, etc.  In any case, I’ll be writing more about “how much math you need” in another blog post.<\/p>\n
Ok, so you don’t need to know that much math to get stared, but you’re not entirely off the hook.  As I noted above, you still need to know how to use the tools properly.<\/p>\n
In some sense, this is one of the challenges of using machine learning tools in R: many of them be difficult to use.  <\/p>\n
R has many packages for implementing various machine learning methods, but unfortunately many of these tools were designed separately, and they are not always consistent in how they work.  The syntax for some of the machine learning tools is very awkward, and syntax from one tool to the next is not always the same.  If you don’t know where to start, machine learning in R can become very confusing.<\/p>\n
This is why I recommend using the caret package to do machine learning in R.<\/p>\n
A quick introduction to caret<\/h3>\n
For starters, let’s discuss what caret is.<\/p>\n
The caret package is a set of tools for building machine learning models in R.  The name “caret” stands for C<\/b>lassification A<\/b>nd RE<\/b>gression T<\/b>raining.  As the name implies, the caret package gives you a toolkit for building classification models and regression models.  Moreover, caret provides you with essential tools for:<\/p>\n
– Data preparation, including: imputation, centering\/scaling data, removing correlated predictors, reducing skewness
\n– Data splitting
\n– Model evaluation
\n– Variable selection<\/p>\n
Caret simplifies machine learning in R<\/h4>\n
While caret has broad functionality, the real reason to use caret is that it’s simple and easy to use.<\/p>\n
As noted above, one of the major problems with machine learning in R is that most of R’s different machine learning tools have different interfaces.  They almost all “work” a little differently from one another: the syntax is slightly different from one modeling tool to the next; tools for different parts of the machine learning workflow don’t always “work well” together;  tools for fine tuning models or performing critical functions may be awkward or difficult to work with.  Said succinctly, R has many machine learning tools, but they can be extremely clumsy to work with.<\/p>\n
Caret solves this problem.  To simplify the process, caret provides tools for almost every part of the model building process, and moreover, provides a common interface to these different machine learning methods.<\/p>\n
For example, caret provides a simple, common interface to almost every machine learning algorithm in R.  When using caret, different learning methods like linear regression, neural networks, and support vector machines, all share a common syntax (the syntax is basically identical, except for a few minor changes).<\/p>\n
Moreover, additional parts of the machine learning workflow \u2013 like cross validation and parameter tuning \u2013 are built directly into this common interface.  <\/p>\n
To say that more simply, caret provides you with an easy-to-use toolkit for building many different model types and executing critical parts of the ML workflow.  This simple interface enables rapid, iterative modeling.  In turn, this iterative workflow will allow you to develop good models faster, with less effort, and with less frustration.<\/p>\n
Caret’s syntax<\/h3>\n
Now that you’ve been introduced to caret, let’s return to the example above (of mpg<\/inline_code> vs wt<\/inline_code>) and see how caret works.<\/p>\n
Again, imagine you want to learn the relationship between mpg<\/inline_code> and wt<\/inline_code>.  As noted above, in mathematical terms, this means identifying a function, \"f(x)\", that describes the relationship between wt<\/inline_code> and mpg<\/inline_code>.<\/p>\n
Here in this example, we’re going to make an additional assumption that will simplify the process somewhat: we’re going to assume that the relationship is linear; we’ll assume that that it can be described by a straight line of the form \"f(x) = \beta_0 + \beta_1x\".<\/p>\n
In terms of our modeling effort, this means that we’ll be using linear regression to build our machine learning model.<\/p>\n
Without going into the details of linear regression (I’ll save that for another blog post), let’s look at how we implement linear regression with caret.<\/p>\n
The train()<\/inline_code> function<\/h4>\n
The core of caret’s functionality is the train()<\/inline_code> function.<\/p>\n
train()<\/inline_code> is the function that we use to “train” the model.  That is, train is the function that will “learn” the relationship between mpg<\/inline_code> and wt<\/inline_code>.<\/p>\n
Let’s take a look at this syntactically. <\/p>\n
Here is the syntax for a linear regression model, regressing mpg<\/inline_code> on wt<\/inline_code>.<\/p>\n
\r\n#~~~~~~~~~~~~~~~~~~~~~~~~~~\r\n# Build model using train()\r\n#~~~~~~~~~~~~~~~~~~~~~~~~~~\r\n\r\nrequire(caret)\r\n\r\nmodel.mtcars_lm <- train(mpg ~ wt\r\n                        ,data = mtcars\r\n                        ,method = \"lm\"\r\n                        )\r\n<\/pre>\n
 
\nThat's it.  The syntax for building a linear regression is extremely simple with caret.<\/p>\n
Now that we have a simple model, let's quickly extract the regression coefficients and plot the model (i.e., plot the linear function that describes the relationship between mpg<\/inline_code> and wt<\/inline_code>).<\/p>\n
\r\n#~~~~~~~~~~~~~~~~~~~~~~~~~~\r\n# Retrieve coefficients for\r\n#  - slope\r\n#  - intercept\r\n#~~~~~~~~~~~~~~~~~~~~~~~~~~\r\n\r\ncoef.icept <- coef(model.mtcars_lm$finalModel)[1]\r\ncoef.slope <- coef(model.mtcars_lm$finalModel)[2]\r\n\r\n\r\n#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r\n# Plot scatterplot and regression line\r\n#  using ggplot()\r\n#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r\n\r\nggplot(data = mtcars, aes(x = wt, y = mpg)) +\r\n  geom_point() +\r\n  geom_abline(slope = coef.slope, intercept = coef.icept, color = \"red\")\r\n\r\n<\/pre>\n
 
\n\"2016-04-06_quick-intro-to-machine-learning-in-R-with-Caret__regression1\"<\/p>\n
Now, let's look more closely at the syntax and how it works.<\/p>\n
When training a model using train()<\/inline_code>, you only need to tell it a few things:
\n- The dataset you're working with
\n- The target variable you're trying to predict (e.g., the mpg<\/inline_code> variable)
\n- The input variable (e.g., the wt<\/inline_code> variable)
\n- The machine learning method you want to use (in this case \"linear regression\")<\/p>\n
Formula notation<\/h4>\n
In caret's syntax, you identify the target variable and input variables using the \"formula notation.\"<\/p>\n
The basic syntax for formula notation is y ~ x<\/inline_code>, where y<\/inline_code> is your target variable, and x<\/inline_code> is your predictor.  <\/p>\n
Effectively, y ~ x<\/inline_code> tells caret \"I want to predict y<\/inline_code> on the basis of a single input, x<\/inline_code>.\"<\/p>\n
Now, with this knowledge about caret's formula syntax, let's reexamine the above code.  Because we want to predict mpg<\/inline_code> on the basis of wt<\/inline_code>, we use the formula mpg ~ wt<\/inline_code>.  Again, this line of code is the \"formula\" that tells train()<\/inline_code> our target variable and our input variable.  If we translate this line of code into English, we're effectively telling train()<\/inline_code>, \"build a model that predicts mpg<\/inline_code> (miles per gallon) on the basis of wt<\/inline_code> (car weight).\"<\/p>\n
The data = parameter <\/h4>\n
The train()<\/inline_code> function also has a data =<\/inline_code> parameter.  This basically tells the train()<\/inline_code> function what dataset we're using to build the model.  Said differently, if we're using the formula mpg ~ wt<\/inline_code> to indicate the target and predictor variables, then we're using the data =<\/inline_code> parameter to tell caret where to find those variables.  <\/p>\n
So basically, data = mtcars<\/inline_code> tells the caret function that the data and the relevant variables can be found in the mtcars<\/inline_code> dataset.<\/p>\n
The method =<\/inline_code> parameter <\/h4>\n
Finally, we see the method =<\/inline_code> parameter.  This parameter indicates what machine learning method we want to use to predict y<\/inline_code>.  In this case, we're building a linear regression model, so we are using the argument \"lm\"<\/inline_code>.<\/p>\n
Keep in mind, however, we could select a different learning method.  Although it's beyond the scope of this blog post to discuss all of the possible learning methods that we could use here, there are many different methods we could use.  For example, if we wanted to use the k-nearest neighbor technique, we could use the \"knn\"<\/inline_code> argument instead.  If we did that, train()<\/inline_code> would still predict mpg<\/inline_code> on the basis of wt<\/inline_code>, but would use a different statistical technique to make that prediction.  This would yield a different model; a model that makes different predictions.  <\/p>\n
Again, it's beyond the scope of this post to discuss all of the different model types.  However, as you learn more about machine learning, and want to try out more advanced machine learning techniques, this is how you can implement them.  You simply change the learning method by changing the argument of the method =<\/inline_code> parameter.<\/p>\n
This is a good place to reiterate one of caret's primary advantages: switching between model types is extremely easy when we use caret's train()<\/inline_code> function.  Again, if you want to use  linear regression to model your data, you just type in \"lm\"<\/inline_code> for the argument to method =<\/inline_code>; if you want to change the learning method to k-nearest neighbor, you just replace \"lm\"<\/inline_code> with \"knn\"<\/inline_code>.<\/p>\n
Caret's syntax allows you to very easily change the learning method.  In turn, this allows you to \"try out\" and evaluate many different learning methods rapidly and iteratively.  You can just re-run your code with different values for the method<\/inline_code> parameter, and compare the results for each method.<\/p>\n
Next steps<\/h3>\n
Now that you have a high-level understanding of caret, you're ready to dive deeper into machine learning in R.  <\/p>\n
Keep in mind though, if you're new to machine learning, there's still lots more to learn.  Machine learning is intricate and fascinatingly complex.  Moreover, caret has a variety of additional tools for model building.  We've just scratched the surface here.<\/p>\n
At Sharp Sight Labs, we'll be creating blog posts to teach you more of the basics, including tutorials about:
\n- the bias-variance tradeoff
\n- deeper looks at regression
\n- classification
\n- data preparation
\n- and more.<\/p>\n
In the mean time, send me your questions.  <\/p>\n
If you have questions about machine learning, or topics you're struggling with, sign up for the email list.  Once you're on the email list, reply directly to any of the emails and send in your questions.<\/p>\n","protected":false},"excerpt":{"rendered":"
If you’ve been using R for a while, and you’ve been working with basic data visualization and data exploration techniques, the next logical step is to start learning some machine learning. To help you begin learning about machine learning in R, I’m going to introduce you to an R package: the caret package. We’ll build … Read more<\/a><\/p>\n","protected":false},"author":1,"featured_media":2446,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_et_pb_use_builder":"","_et_pb_old_content":"","_et_gb_content_width":"","om_disable_all_campaigns":false,"footnotes":""},"categories":[19,10],"tags":[],"publishpress_future_action":{"enabled":false,"date":"2024-05-04 06:03:31","action":"change-status","newStatus":"draft","terms":[],"taxonomy":"category"},"_links":{"self":[{"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/posts\/2437"}],"collection":[{"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/comments?post=2437"}],"version-history":[{"count":0,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/posts\/2437\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/media\/2446"}],"wp:attachment":[{"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/media?parent=2437"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/categories?post=2437"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.sharpsightlabs.com\/wp-json\/wp\/v2\/tags?post=2437"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}