Revolutions

Handling dates and times in R: a free online course

If you ever need to work with data involving dates, times or durations in R, then take a look at this free course on LinkedIn Learning presented by Mark Niemann-Ross: R Programming in Data Science: Dates and Times. Here's the course overview from the introductory video:

When did Mount St Helens last erupt? How many birds migrated south this month? Which month last year was the coldest on average? These are questions related to time. And if you're going to perform calculations on this type of data, then you need date and time data structures. I

I'll show you how to store dates and times, how to retrieve dates and times, and how to add and subtract dates and times to discover the duration of an event or the difference between two dates. I'll show how to handle dates for business research and for financial forecasting. We'll explore functions include with base R for dates and time calculations, and we'll explore packages that provide special ways to work with dates and times. 

The course does assume some basic familiarity with R syntax, but does start from the beginning with the base R date and time classes before moving on to the newer Tidyverse packages for handling date and time data. Each chapter also includes a quiz to test your knowledge.

The course content is free to view, and all the R scripts associated with the course are available to download as well. 

LinkedIn Learning: R Programming in Data Science: Dates and Times

Guide to a high-performance, powerful R installation

R is an amazing language with 25 years of development behind it, but you can make the most from R with additional components. An IDE makes developing in R more convenient; packages extend R's capabilities; and multi-threaded libraries make computations faster. 

Since these additional components aren't included on the official R website, getting the ideal R environment set up can be a bit tricky. Fortunately, there's a handy R installation guide by Mauricio Vargas that explains how to get everything you need set up on Windows, Mac and Ubuntu Linux. On each platform, the guide describes how to install:

• The R language engine
• The RStudio IDE.
• The tidyverse suite of packages
• Multi-threaded math libraries (BLAS). On Windows, Mauricio recommends Microsoft R Open ("what made my R and Windows experience amazing"). For Mac and Unix he suggests installing OpenBLAS, but I'll add that Microsoft R Open provides BLAS acceleration on those platforms as well. It's easy to configure RStudio to use Microsoft R Open, too.

Find all the details in the installation guide, linked below.

DataCamp Community: How to install R on Windows, Mac OS X and Ubuntu

A guide to working with character data in R

R is primarily a language for working with numbers, but we often need to work with text as well. Whether it's formatting text for reports, or analyzing natural language data, R provides a number of facilities for working with character data. Handling Strings with R, a free (CC-BY-NC-SA) e-book by UC Berkeley's Gaston Sanchez, provides an overview of the ways you can manipulate characters and strings with R. 

There are many useful sections in the book, but a few selections include:

• C-style formatting — very useful for preparing tabular data for reports
• String manipulation with the stringr package — which provides some welcome consistency in handling strings with R
• Regular expressions — the savior and/or curse for many data extraction problem

Note that the book does not cover analysis of natural language data, for which you might want to check out the CRAN Task View on Natural Language Processing or the book Text Mining with R: A Tidy Approach. It's also sadly silent on the topic of character encoding in R, a topic that often causes problems when dealing with text data, especially from international sources. Nonetheless, the book is a really useful overview of working with text in R, and has been updated extensively since it was last published in 2014. You can read Handling Strings with R at the link below.

Gaston Sanchez: Handling Strings with R

R and Docker

If you regularly have to deal with specific versions of R, or different package combinations, or getting R set up to work with other databases or applications then, well, it can be a pain. You could dedicate a special machine for each configuration you need, I guess, but that's expensive and impractical. You could set up virtual machines in the cloud which works well for one-off situations, but gets tedious having to re-configure a new VM each time. Or, you could use Docker containers, which were expressly designed to make it quick easy to configure and launch an independent and secure collection of software and services.

If you're new to the concept of Docker containers, here's a docker tutorial for data scientists. But the concepts are pretty simple. At Docker hub, you can search "images" — basically, bundles of software with pre-configured settings — contributed by the community and by vendors. (You'll be referring to the images by name, for example: rocker/r-base.) You can then create a "container" (a running instance of that image) on your machine with the docker application, or in the cloud using the tools offered by your provider of choice.

For R users, there's a wide array of pre-configured Docker images for R available since 2014, thanks to the Rocker project. You can browse the rocker repository at Docker Hub to see everything available, but it includes:

• Simple images containing just the latest official R release or the latest daily R build.
• Images containing both R and RStudio Server.
• Images with the tidyverse suite of packages pre-installed.
• Version-stable images, snapshotted to specific R (and RStudio versions) and the R package ecosystem at specific points in time. If you retrieve one of these images using a tag, your docker image will always include the same software, even months or years down the line. These are perfect for production instances, where reproducibility is paramount.

I find the images containing RStudio Server super convenient whenever I need to try out something in a specific R version. All I need to do is provide the image name to Azure Container Instances, and make sure port 8787 is open:

Creating a container for R 3.4.1 with the tidyverse packages and RStudio Server.

 

Be sure to open port 8787 here for browser access.

That's it for the configuration, and after the instance is ready (about 2 minutes) I can use a web browser to visit http://40.121.205.121:8787/ to find a completely fresh R instance and the RStudio IDE. (The actual IP address will be provided for you by Container Instances, and can be found in the Overview section for your instance in the Azure Portal.)

You can of course use other cloud providers as well: Andre Heiss provides this guide for setting up a rocker image in Digital Ocean, and also provides some handy tips for creating your own Docker Files to create custom images of your own design. For more on the Rocker project, follow the link below.

The Rocker Project: Docker Containers for the R Environment

A fresh look for base graphics

While ggplot2 (and its various extensions) is often the go-to package for graphics in R these days, if you need to step outside the boundaries of what ggplot2 can do, you can always step back to base R graphics (and the built-in lattice package) and customize to your hearts content.

The problem is that (unlike for ggplot2) the default look for base graphics is kinda ... meh. That being said, the base graphics system offers almost unlimited flexibility, both via function options and via the par system for modifying layouts and graphic defaults. As Colin Gallespie explains in a recent blog post, you can take a scatterplot that looks, by default, like this:

and with a little extra code, make it look like this:

Find out how in Colin's blog post, linked below.

The Jumping Rivers Blog: Styling Base R Graphics

Scraping a website with 5 lines of R code

In what is rapidly becoming a series — cool things you can do with R in a tweet — Julia Silge demonstrates scraping the list of members of the US house of representatives on Wikipedia in just 5 R statements:

library(rvest)
library(tidyverse)

h <- read_html("https://t.co/gloY1eErBn")

reps <- h %>%
html_node("#mw-content-text > div > table:nth-child(18)") %>%
html_table()

reps <- reps[,c(1:2,4:9)] %>%
as_tibble() pic.twitter.com/25ANm7BHkj

— Julia Silge (@juliasilge) January 12, 2018

Since Twitter munges the URL in the third line when you cut-and-paste, here's a plain-text version of Julia's code:

library(rvest)
library(tidyverse)

h <- read_html("https://en.wikipedia.org/wiki/Current_members_of_the_United_States_House_of_Representatives")

reps <- h %>%
 html_node("#mw-content-text > div > table:nth-child(18)") %>%
 html_table()

reps <- reps[,c(1:2,4:9)] %>% as_tibble()

And sure enough, here's what the reps object looks like in the RStudio viewer:

As Julia notes it's not perfect, but you're still 95% of the way there to gathering data from a page intended for human rather than computer consumption. Impressive!

The British Ecological Society's Guide to Reproducible Science

The British Ecological Society has published a new volume in their Guides to Better Science series: A Guide to Reproducible Code in Ecology and Evolution (pdf). The introduction, by , describes its scope:

A Guide to Reproducible Code covers all the basic tools and information you will need to start making your code more reproducible. We focus on R and Python, but many of the tips apply to any programming language. Anna Krystalli introduces some ways to organise files on your computer and to document your workflows. Laura Graham writes about how to make your code more reproducible and readable. François Michonneau explains how to write reproducible reports. Tamora James breaks down the basics of version control. Finally, Mike Croucher describes how to archive your code. We have also included a selection of helpful tips from other scientists.

The guide proposes a simple reproducible project workflow, and a guide to organizing projects for reproducibility. The Programming section provides concrete tips and traps to avoid (example: use relative, not absolute pathnames), and the Reproducible Reports section provides a step-by-step guide for generating reports with R Markdown.

While written for an ecology audience (and also including some gorgeous photography of animals), this guide would be useful for anyone in the science looking to implement a reproducible workflow. You can download the guide at the link below.

British Ecological Society: A Guide to Reproducible Code in Ecology and Evolution (via Laura Graham)

AI School: Microsoft R and SQL Server ML Services

If you'd like to learn how you use R to develop AI applications, the Microsoft AI School now features a learning path focused on Microsoft R and SQL Server ML Services. This learning path includes eight modules, each comprising detailed tutorials and examples:

• Doing Data Analysis using R
• Analyzing Big Data with Microsoft R Server
• Introduction to SQL Server R Services
• Microsoft R for SQL Architects
• Microsoft R for T-SQL Professionals
• Microsoft R for Data Science
• Microsoft R with Spark on HDInsight
• Microsoft R Server for Data Science (with Spark)

All of the Microsoft AI School learning paths are free to access, and the content is hosted on Github (where feedback is welcome!). You can access this course and many others at the link below.

Microsoft AI School: Microsoft R and SQL Server ML Services 

Tutorial: Azure Data Lake analytics with R

The Azure Data Lake store is an Apache Hadoop file system compatible with HDFS, hosted and managed in the Azure Cloud. You can store and access the data within directly via the API, by connecting the filesystem directly to Azure HDInsight services, or via HDFS-compatible open-source applications. And for data science applications, you can also access the data directly from R, as this tutorial explains. 

To interface with Azure Data Lake, you'll use U-SQL, a SQL-like language extensible using C#. The R Extensions for U-SQL allow you to reference an R script from a U-SQL statement, and pass data from Data Lake into the R Script. There's a 500Mb limit for the data passed to R, but the basic idea is that you perform the main data munging tasks in U-SQL, and then pass the prepared data to R for analysis. With this data you can use any function from base R or any R package. (Several common R packages are provided in the environment, or you can upload and install other packages directly, or use the checkpoint package to install everything you need.) The R engine used is R 3.2.2.

The tutorial walks you through the following stages:

• Exercise 1 - Inline R code.
• Exercise 2 - Deploy R script as resource.
• Exercise 3 - Check the R environment in ADLA. Install the magrittr package.
• Exercise 4 - Using checkpoint to create a zip file containing required packages and all the dependencies. Demonstrate how to deploy and use dplyr package.
• Exercise 5 - Understanding how partitioning works in ADLA. Specifically the REDUCE operation.
• Exercise 6 - About rReturnType as “charactermatrix”.
• Exercise 7 - Save the trained model. Deploy trained model for scoring.
• Exercise 8 - Use R scripts as combiners (using COMBINE and Extension.R.Combiner).
• Exercise 9 - Use rxDTree() from RevoScaleR package.
• Advanced - More complex examples.

To get started with the tutorial, check the link below for the prerequisites and then hop on over to Github for the complete walkthrough. You can also follow along with this Jupyter notebook.

Cortana Intelligence Gallery: Getting Started with using Azure Data Lake Analytics with R - A Tutorial

Practical Data Science for Stats

PeerJ Preprints has recently published a collection of articles that focus on the practical side of statistical analysis: Practical Data Science for Stats. While the articles are not peer-reviewed, they have been selected and edited by Jennifer Bryan and Hadley Wickham, both well-respected members of the R community. And while the articles provide great advice for any data scientist, the content does heavily feature the use of R, so it's particularly useful to R users.

There are 16 articles in the collection (with possibly more to come?). Here are just a few examples that caught my eye:

• Bryan: "Excuse me, do you have a moment to talk about version control?". Practical advice on using Git, Github and Markdown for data science projects, with a focus on R.
• Marwick, Boettiger and Mullen: Packaging data analytical work reproducibly using R (and friends). On using R packages as a vehicle for sharing research in a reproducible manner.
• Taylor and Letham: Forecasting at Scale. On using the Prophet package for production-scale forecasting of time series.
• Ross, Wickham, and Robinson: Declutter your R workflow with tidy tools. On using the tidyverse to make data analysis in R as smooth as possible.
• Eddelbuettel and Balamuta: Extending R with C++: A Brief Introduction to Rcpp. An introduction to the Rcpp package for R.

There's lots more to explore in the collection as well, including case studies on using R at the likes of AirBnB and the New York Mets. Check out the entire collection at the link below.

PeerJ Collections: Practical Data Science for Stats (via Jenny Bryan)