The aim of machine learning is to uncover hidden patterns and unknown correlations, and to find useful information from data. In addition to this, through incorporation with data analysis, machine learning can be used to perform predictive analysis. With machine learning, the analysis of business operations and processes is not limited to human scale thinking; machine scale analysis enables businesses to capture hidden values in big data.

Machine learning has similarities to the human reasoning process. Unlike traditional analysis, the generated model cannot evolve as data is accumulated. Machine learning can learn from the data that is processed and analyzed. In other words, the more data that is processed, the more it can learn.

R, as a dialect of GNU-S, is a powerful statistical language that can be used to manipulate and analyze data. Additionally, R provides many machine learning packages and visualization functions, which enable users to analyze data on the fly. Most importantly, R is open source and free.

Using R greatly simplifies machine learning. All you need to know is how each algorithm can solve your problem and then you can simply use a written package to quickly generate prediction models on data with a few command lines. For example, you can perform Naïve Bayes for spam mail filtering, conduct k-means clustering for customer segmentation, use linear regression to forecast house prices, or implement a hidden Markov model to predict the stock market, as shown in the following screenshot:

Moreover, you can perform nonlinear dimension reduction to calculate the dissimilarity of image data and visualize the clustered graph, as shown in the following screenshot. All you need to do is follow the recipes provided in this book:

This chapter serves as an overall introduction to machine learning and R; the first few recipes introduce how to set up the R environment and the integrated development environment, RStudio. After setting up the environment, the following recipe introduces package installation and loading. In order to understand how data analysis is practiced using R, the next four recipes cover data read/write, data manipulation, basic statistics, and data visualization using R. The last recipe in the chapter lists useful data sources and resources.

To use R, you must first install it on your computer. This recipe gives detailed instructions on how to download and install R.

If you are new to the R language, you can find a detailed introduction, language history, and functionality on the official website (http://www.r-project.org/). When you are ready to download and install R, please access the following link: http://cran.r-project.org/.

Please perform the following steps to download and install R for Windows and macOS:

1. Go to the R CRAN website, http://www.r-project.org/, and click on the download R link, that is, http://cran.r-project.org/mirrors.html):

2. You may select the mirror location closest to you:

3. Select the correct download link based on your operating system:

As the installation of R differs for Windows and macOS, the steps required to install R for each OS are provided here.

For Windows:

1. Click on Download R for Windows, as shown in the following screenshot, and then click on base:

2. Click on Download R 3.x.x for Windows:

3. The installation file should be downloaded. Once the download is finished, you can double-click on the installation file and begin installing R, It will ask for you selecting setup language:

4. The next screen will be an installation screen; click on Next on all screens to complete the installation. Once installed, you can see the shortcut icon on the desktop:

5. Double-click on the icon and it will open the R Console:

For macOS X:

1. Go to Download R for (Mac) OS X, as shown in the following screenshot.
2. Click on the latest version (R-3.4.1.pkg file extension) according to your macOS version:

3. Double-click on the downloaded installation file (.pkg extension) and begin to install R. Leave all the installation options as the default settings if you do not want to make any changes:

4. Follow the onscreen instructions through Introduction, Read Me, License, Destination Select, Installation Type, Installation, and Summary, and click on Continue to complete the installation.

5. After the file is installed, you can use spotlight search or go to the Applications folder to find R:

6. Click on R to open R Console:

As an alternative to downloading a Mac .pkg file to install R, Mac users can also install R using Homebrew:

1. Download XQuartz-2.X.X.dmg from https://xquartz.macosforge.org/landing/.
2. Double-click on the .dmg file to mount it.
3. Update brew with the following command line:

        $ brew update  

4. Clone the repository and symlink all its formulae to homebrew/science:

        $ brew tap homebrew/science  

5. Install gfortran:

        $ brew install gfortran  

6. Install R:

        $ brew install R      

For Linux users, there are precompiled binaries for Debian, RedHat, SUSE, and Ubuntu. Alternatively, you can install R from a source code. Besides downloading precompiled binaries, you can install R for Linux through a package manager. Here are the installation steps for CentOS and Ubuntu.

Downloading and installing R on Ubuntu:

1. Add the entry to the /etc/apt/sources.list file replace <> with appropriate value:

        $ sudo sh -c "echo 'deb http:// <cran mirros site 
        url>/bin/linux/ubuntu <ubuntu version>/' >> /etc/apt/sources.list"

2. Then, update the repository:

        $ sudo apt-get update  

3. Install R with the following command:

        $ sudo apt-get install r-base  

4. Start R in the command line:

        $ R  

Downloading and installing R on CentOS 5:

1. Get the rpm CentOS 5 RHEL EPEL repository of CentOS 5:

        $ wget
        http://dl.fedoraproject.org/pub/epel/5/x86_64/epel-release-5-
        4.noarch.rpm  

2. Install the CentOS 5 RHEL EPEL repository:

        $ sudo rpm -Uvh epel-release-5-4.noarch.rpm  

3. Update the installed packages:

        $ sudo yum update  

4. Install R through the repository:

        $ sudo yum install R  

5. Start R in the command line:

        $ R  

Downloading and installing R on CentOS 6:

1. Get the rpm CentOS 5 RHEL EPEL repository of CentOS 6:

        $ wget
        http://dl.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-
        8.noarch.rpm  

2. Install the CentOS 5 RHEL EPEL repository:

        $ sudo rpm -Uvh epel-release-6-8.noarch.rpm  

3. Update the installed packages:

        $ sudo yum update  

4. Install R through the repository:

        $ sudo yum install R  

5. Start R in the command line:

        $ R  

Downloading and installing R on Fedora [Latest Version]:

$ dnf install R  

This will install R and all its dependencies.

CRAN provides precompiled binaries for Linux, macOS X, and Windows. For macOS and Windows users, the installation procedures are straightforward. You can generally follow onscreen instructions to complete the installation. For Linux users, you can use the package manager provided for each platform to install R or build R from the source code.

• For those planning to build R from the source code, refer to R Installation and Administration (http://cran.r-project.org/doc/manuals/R-admin.html), which illustrates how to install R on a variety of platforms

To write an R script, one can use R Console, R commander, or any text editor (such as EMACS, VIM, or sublime). However, the assistance of RStudio, an integrated development environment (IDE) for R, can make development a lot easier.

RStudio provides comprehensive facilities for software development. Built-in features, such as syntax highlighting, code completion, and smart indentation, help maximize productivity. To make R programming more manageable, RStudio also integrates the main interface into a four-panel layout. It includes an interactive R Console, a tabbed source code editor, a panel for the currently active objects/history, and a tabbed panel for the file browser/plot window/package install window/R help window. Moreover, RStudio is open source and is available for many platforms, such as Windows, macOS X, and Linux. This recipe shows how to download and install RStudio.

RStudio requires a working R installation; when RStudio loads, it must be able to locate a version of R. You must therefore have completed the previous recipe with R installed on your OS before proceeding to install RStudio.

Perform the following steps to download and install RStudio for Windows and macOS users:

1. Access RStudio's official site by using the following URL: http://www.rstudio.com/products/RStudio/

2. For the desktop version installation, click on RStudio Desktop under the Desktop section. It will redirect you to the bottom of the home page:

3. Click on the DOWNLOAD RSTUDIO DESKTOP button (http://www.rstudio.com/products/rstudio/download/), it will display download page, with the option of open source license and commercial license. Scroll down to RStudio Desktop Open Source License and click on DOWNLOAD button:

4. It will display different installers for different OS types. Select the appropriate option and download the RStudio:

5. Install RStudio by double-clicking on the downloaded packages. For Windows users, follow the onscreen instructions to install the application:

6. For Mac users, simply drag the RStudio icon to the Applications folder.
7. Start RStudio:

Perform the following steps for downloading and installing RStudio for Ubuntu/Debian and RedHat/CentOS users:

For Debian(6+)/Ubuntu(10.04+) 32 bit:

$ wget http://download1.rstudio.org/rstudio-0.98.1091-i386.deb
$ sudo gdebi rstudio-0.98. 1091-i386.deb  

For Debian(6+)/Ubuntu(10.04+) 64 bit:

$ wget http://download1.rstudio.org/rstudio-0.98. 1091-amd64.deb
$ sudo gdebi rstudio-0.98. 1091-amd64.deb  

For RedHat/CentOS(5,4+) 32 bit:

$ wget http://download1.rstudio.org/rstudio-0.98. 1091-i686.rpm
$ sudo yum install --nogpgcheck rstudio-0.98. 1091-i686.rpm  

For RedHat/CentOS(5,4+) 64 bit:

$ wget http://download1.rstudio.org/rstudio-0.98. 1091-x86_64.rpm
$ sudo yum install --nogpgcheck rstudio-0.98. 1091-x86_64.rpm  

The RStudio program can be run on the desktop or through a web browser. The desktop version is available for the Windows, macOS X, and Linux platforms with similar operations across all platforms. For Windows and macOS users, after downloading the precompiled package of RStudio, follow the onscreen instructions, shown in the preceding steps, to complete the installation. Linux users may use the package management system provided for installation.

• In addition to the desktop version, users may install a server version to provide access to multiple users. The server version provides a URL that users can access to use the RStudio resources. To install RStudio, please refer to the following link: http://www.rstudio.com/ide/download/server.html. This page provides installation instructions for the following Linux distributions: Debian (6+), Ubuntu (10.04+), RedHat, and CentOS (5.4+).
• For other Linux distributions, you can build RStudio from the source code.

After successfully installing R, users can download, install, and update packages from the repositories. As R allows users to create their own packages, official and non-official repositories are provided to manage these user-created packages. CRAN is the official R package repository. Currently, the CRAN package repository features 11,589 available packages (as of 10/11/2017). Through the use of the packages provided on CRAN, users may extend the functionality of R to machine learning, statistics, and related purposes. CRAN is a network of FTP and web servers around the world that store identical, up-to-date versions of code and documentation for R. You may select the closest CRAN mirror to your location to download packages.

Start an R session on your host computer.

Perform the following steps to install and load R packages:

1. Load a list of installed packages:

        > library()

2. Set the default CRAN mirror:

        > chooseCRANmirror()

R will return a list of CRAN mirrors, and then ask the user to either type a mirror ID to select it, or enter zero to exit:

1. Install a package from CRAN; take package e1071 as an example:

        > install.packages("e1071")

2. Update a package from CRAN; take package e1071 as an example:

        > update.packages("e1071")

3. Load the package:

        > library(e1071)  

4. If you would like to view the documentation of the package, you can use the help function:

        > help(package ="e1071")  

5. If you would like to view the documentation of the function, you can use the help function:

        > help(svm, e1071)  

6. Alternatively, you can use the help shortcut, ?, to view the help document for this function:

        > ?e1071::svm

7. If the function does not provide any documentation, you may want to search the supplied documentation for a given keyword. For example, if you wish to search for documentation related to svm:

        > help.search("svm")

8. Alternatively, you can use ?? as the shortcut for help.search:

        > ??svm

9. To view the argument taken for the function, simply use the args function. For example, if you would like to know the argument taken for the lm function:

        > args(lm)

10. Some packages will provide examples and demos; you can use example or demo to view an example or demo. For example, one can view an example of the lm package and a demo of the graphics package by typing the following commands:

        > example(lm)
        > demo(graphics)  

11. To view all the available demos, you may use the demo function to list all of them:

        > demo()

This recipe first introduces how to view loaded packages, install packages from CRAN, and load new packages. Before installing packages, those of you who are interested in the listing of the CRAN package can refer to http://cran.r-project.org/web/packages/available_packages_by_name.html.

When a package is installed, documentation related to the package is also provided. You are, therefore, able to view the documentation or the related help pages of installed packages and functions. Additionally, demos and examples are provided by packages that can help users understand the capability of the installed package.

• Besides installing packages from CRAN, there are other R package repositories, including Crantastic, a community site for rating and reviewing CRAN packages, and R-Forge, a central platform for the collaborative development of R packages. In addition to this, Bioconductor provides R packages for the analysis of genomic data.
• If you would like to find relevant functions and packages, please visit the list of task views at http://cran.r-project.org/web/views/, or search for keywords at http://rseek.org.

Ensure you have completed the previous recipes by installing R on your operating system.

You need to have brief idea about basic data types and structures in R in order to grasp all the recipies in book. This section will give you an overview for the same and make you ready for using R. R supports all the basic data types supported by any other programming and scripting language. In simple words, data can be of numeric, character, date, and logical type. As the name suggests, numeric means all type of numbers, while logical allows only true and false. To check the type of data, the class function, which will display the class of the data, is used.

Perform following task on R Console or RStudio:

> x=123 
> class(x) 
Output: 
[1] "numeric"
> x="ABC"
> class(x)
Output:
[1] "character"

R supports different types of data structures to store and process data. The following is a list of basic and commonly used data structures used in R:

• Vectors
• List
• Array
• Matrix
• DataFrames

A vector is a container that stores data of same type. It can be thought of as a traditional array in programming language. It is not to be confused with mathematical vector which have rows and columns. To create a vector the c() function, which will combine the arguments, is used. One of the beautiful features of vectors is that any operation performed on vector is performed on each element of the vector. If a vector consists of three elements, adding two will increases every element by two.

Perform the following steps to create and see vector in R:

> x=c(1,2,3,4) # c(1:4) 
> x 
Output: 
[1] 1 2 3 4 
> x=c(1,2,3,4,"ABC") 
> x 
Output: 
[1] "1" "2" "3" "4" "ABC" 
> x * 2 
Output: 
[1] 2 4 6 8 
> sqrt(x) 
Output: 
[1] 1.000000 1.414214 1.732051 2.000000 
> y = x==2 
> y 
Output: 
[1] FALSE TRUE FALSE FALSE 
> class(y) 
Output: 
[1] "logical" 
> t = c(1:10) 
> t 
Output: 
[1] 1 2 3 4 5 6 7 8 9 10

Printing a vector will starts with index [1] which shows the elements are indexed in vector and it starts from 1, not from 0 like other languages. Any operation done on a vector is applied on individual elements of the vector, so the multiplication operation is applied on individual elements of the vector. If vector is passed as an argument to any inbuilt function, it will be applied on individual elements. You can see how powerful it is and it removes the need to write the loops for doing the operation. The vector changes the type on basis of data it holds and operation we apply on it. Using x==2 will check each element of vector for equality with two and returns the vector with logical value, that is, TRUE or FALSE. There are many other ways of creating a vector; one such way is shown in creating vector t.

Unlike a vector, a list can store any type of data. A list is, again, a container that can store arbitrary data. A list can contain another list, a vector, or any other data structure. To create a list, the list function is used.

Perform the following steps to create and see a list in R:

> y = list(1,2,3,"ABC") 
> y 
Output: 
[[1]]
[1]1
[[2]]
[1]2
[[3]]
[1]3
[[4]]
[1] "ABC" 
> y = list(c(1,2,3),c("A","B","C")) 
> y 
Output: 
[[1]]
[1] 1 2 3
[[2]]
[1] "A" "B" "C"

A list, as said, can contain anything; we start with a simple example to store some elements in a list using the list function. In the next step, we create a list with a vector as element of the list. So, y is a list with its first element as vector of 1, 2, 3 and its second element as vector of A, B, and C.

An array is nothing but a multidimensional vector, and can store only the same type of data. The way to create a multidimensional vector dimension is specified using dim.

Perform the following steps to create and see an array in R:

> t = array(c(1,2,3,4), dim=c(2,2)) # Create two dimensional array 
> t 
Output: 
    [,1]       [,2]
[1,] 1          3
[2,] 2          4 
> arr = array(c(1:24), dim=c(3,4,2)) # Creating three dimensional array 
> arr 
Output: 
, , 1   

      [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12
, , 2 
      [,1] [,2] [,3] [,4]
[1,]   13   16   19   22
[2,]   14   17   20   23 
[3,]   15   18   21   24 

Creating an array is straightforward. Use the array function and provide the value for n^th row; it will create a two-dimensional array with appropriate columns.

A matrix is like a DataFrame, with the constraint that every element must be of the same type.

Perform the following steps to create and see a matrix in R:

> m = matrix(c(1,2,3,4,5,6), nrow=3) 
> m 
Output: 
[,1]       [,2]
[1,] 1      4
[2,] 2      5
[3,] 3      6

DataFrame can be seen as an Excel spreadsheet, with rows and columns where every column can have different data types. In R, each column of a DataFrame is a vector.

Perform the following steps:

    > p = c(1,2,3)
    > q = c("A","B","C")
    > r = c(TRUE, FALSE, FALSE)
    > d = data.frame(No=p, Name=q, Attendance=r)
    > d
    Output:
           No       Name   Attendance
    1       1          A      TRUE
    2       2          B      FALSE
    3       3          C      FALSE

R allows data to be sliced or to get the subset using various methods.

Perform the following steps to see subsetting. It is assumed that the DataFrame d and matrix m exist from the previous exercise:

> d$No   # Slice the column 
Output: 
[1] 1 2 3 
> d$Name  # Slice the column 
Output: 
[1] A B C 
> d$Name[1] 
Output: 
[1] A 
> d[2,]  # get Row 
Output: 
      No       Name   Attendance
2    2          B          FALSE 
> temp = c(1:100) # Creates a vector of 100 elements from 1 to 100 
> temp[14:16]  # Part from vector 
Output: 
[1] 14 15 16 
> m[,2]    # To access second column from matrix m 
Output: 
[1] 4 5 6 
> m[3,]  # To access third row from matrix m 
Output: 
[1] 3 6 
> m[2,1]  # To access single element from matrix m 
Output: 
[1] 2 
> m[c(1,3), c(2)] # Access [1,2] and [3,2] 
Output: 
[1] 4 6

R provides various ways to read data for processing. It supports reading data from CSV files, Excel files, databases, other statistical tools, binary files, and websites. Apart from this, there are many datasets that come bundled with the R. Just execute the data() command on RStudio or R prompt it will list the datasets available. If you want to create quick dataset you can create a blank DataFrame and use edit command as shown here:

> temp = data.frame()
> edit(temp)  

This will open an Excel like screen for data manipulation as shown in the following screenshot:

Before starting to explore data, you must load the data into the R session. This recipe will introduce methods to load data from a file into the memory, use the predefined data within R, using the data from database.

First, start an R session on your machine. As this recipe involves steps toward the file I/O, if the user does not specify the full path, read and write activity will take place in the current working directory. For working with databases, it is assumed you have working PostgreSQL on your system with some data.

You can simply type getwd() in the R session to obtain the current working directory location. However, if you would like to change the current working directory, you can use setwd("<path>"), where <path> can be replaced with your desired path, to specify the working directory.

Perform the following steps to read and write data with R:

1. To view the built-in datasets of R, type the following command:

        > data() 

2. R will return a list of datasets in a dataset package, and the list comprises the name and description of each dataset.
3. To load the dataset iris into an R session, type the following command:

        > data(iris)  

4. The dataset iris is now loaded into the DataFrame format, which is a common
   data structure in R to store a data table.

5. To view the data type of iris, simply use the class function:

        > class(iris)
        [1] "data.frame"

6. The data.frame console print shows that the iris dataset is in the structure of DataFrame.
7. Use the save function to store an object in a file. For example, to save the loaded iris data into myData.RData, use the following command:

        > save(iris, file="myData.RData")  

8. Use the load function to read a saved object into an R session. For example, to load iris data from myData.RData, use the following command:

        > load("myData.RData")  

9. In addition to using built-in datasets, R also provides a function to import data from text into a DataFrame. For example, the read.table function can format a given text into a DataFrame:

        > test.data = read.table(header = TRUE, text = " 
        + a b 
        + 1 2 
        + 3 4 
        + ") 

10. You can also use row.names and col.names to specify the names of columns and rows:

        > test.data = read.table(text = " 
        + 1 2 
        + 3 4",  
        + col.names=c("a","b"), 
        + row.names = c("first","second")) 

11. View the class of the test.data variable:

        > class(test.data) 
        [1] "data.frame" 

12. The class function shows that the test.data variable contains a DataFrame.
13. In addition to importing data by using the read.table function, you can use the write.table function to export data to a text file:

        > write.table(test.data, file = "test.txt" , sep = " ") 

14. The write.table function will write the content of test.data into test.txt
    (the written path can be found by typing getwd()), with a separation delimiter as white space.
15. Similar to write.table, write.csv can also export data to a file. However, write.csv uses a comma as the default delimiter:

        > write.csv(test.data, file = "test.csv")  

16. With the read.csv function, the csv file can be imported as a DataFrame. However, the last example writes column and row names of the DataFrame to the test.csv file. Therefore, specifying header to TRUE and row names as the first column within the function can ensure the read DataFrame will not treat the header and the first column as values:

        > csv.data = read.csv("test.csv", header = TRUE, row.names=1) 
        > head(csv.data) 
          a b 
        1 1 2 
        2 3 4 

This section will cover how to work with the database. To connect with PostgreSQL, the RPostgreSQL package is required which can be installed using this command:

> install.packages("RPostgreSQL") 

> require("RPostgreSQL") 
> driver = dbDriver("PostgreSQL") 
> connection = dbConnect(driver, dbname="restapp", host="localhost", 
         port=5432, user="postgres", password="postgres") 
> dbExistsTable(connection, "country") 
[1] TRUE

> data = dbGetQuery(connection, "select * from country") 
> class(data) 
Output: 
[1] "data.frame" 
> data 
Output: 
    id         code     name
1    1         US       USA
2    43        AS       Austria
3    55        BR       Brazil

Reading table data will result in to DataFrame in R.

Generally, data for collection may be in multiple files and different formats. To exchange data between files and RData, R provides many built-in functions, such as save, load, read.csv, read.table, write.csv, and write.table.

This example first demonstrates how to load the built-in dataset iris into an R session.
The iris dataset is the most famous and commonly used dataset in the field of machine learning. Here, we use the iris dataset as an example. The recipe shows how to save RData and load it with the save and load functions. Furthermore, the example explains how to use read.table, write.table, read.csv, and write.csv to exchange data from files to a DataFrame. The use of the R I/O function to read and write data is very important as most of the data sources are external. Therefore, you have to use these functions to load data into an R session.

You need to install the package for reading from the database. For all database, you can find the package, after installing the steps mostly remains the same for reading the data from the database.

For the load, read.table, and read.csv functions, the file to be read can also be a complete URL (for supported URLs, use ?url for more information).

On some occasions, data may be in an Excel file instead of a flat text file. The WriteXLS package allows writing an object into an Excel file with a given variable in the first argument and the file to be written in the second argument:

1. Install the WriteXLS package:

        > install.packages("WriteXLS")  

2. Load the WriteXLS package:

        > library("WriteXLS")  

3. Use the WriteXLS function to write the DataFrame iris into a file named iris.xls:

        > WriteXLS("iris", ExcelFileName="iris.xls")