The AUC can be defined as “The probability that a randomly selected case will have a higher test result than a randomly selected control”. Let’s use this definition to calculate and visualize the estimated AUC.

In the figure below, the cases are presented on the left and the controls on the right.

Since we have only 12 patients, we can easily visualize all 32 possible combinations of one case and one control. (Rcode below)

Expanding from this easy-to-follow example, Colman walks us through some of the statistical tests involved. Check it out.

Pablo Casas walks us through Keras on R:

One of the key points in Deep Learning is to understand the dimensions of the vector, matrices and/or arrays that the model needs. I found that these are the types supported by Keras.

In Python’s words, it is the shape of the array.

To do a binary classification task, we are going to create a one-hot vector. It works the same way for more than 2 classes.

For instance:

- The value
`1`

will be the vector`[0,1]`

- The value
`0`

will be the vector`[1,0]`

Keras provides the

`to_categorical`

function to achieve this goal.

This example doesn’t include using CUDA, but the data sizes are small enough that it doesn’t matter much. H/T R-Bloggers

Tanzir Musabbir demonstrates how to set up Amazon ElasticMapReduce to include an RStudio edge node:

RStudio Server provides a browser-based interface for R and a popular tool among data scientists. Data scientist use Apache Spark cluster running on Amazon EMR to perform distributed training. In a previous blog post, the author showed how you can install RStudio Server on Amazon EMR cluster. However, in certain scenarios you might want to install it on a standalone Amazon EC2 instance and connect to a remote Amazon EMR cluster. Benefits of running RStudio on EC2 include the following:

- Running RStudio Server on an EC2 instance, you can keep your scientific models and model artifacts on the instance. You might have to relaunch your EMR cluster to meet your application requirements. By running RStudio Server separately, you have more flexibility and don’t have to depend entirely on an Amazon EMR cluster.
- Installing RStudio on the master node of Amazon EMR requires sharing of resources with the applications running on the same node. By running RStudio on a standalone Amazon EC2 instance, you can use resources as you need without having to share the resources with other applications.
- You might have multiple Amazon EMR clusters in your environment. With RStudio on Edge node, you have the flexibility to connect to any EMR clusters in your environment.
There is one major difference between running RStudio Server on an Amazon EMR cluster vs. running it on a standalone Amazon EC2 instance. In the latter case, the instance needs to be configured as an Amazon EMR client (or edge node). By doing so, you can submit Apache Spark jobs and other Hadoop-based jobs from an instance other than EMR master node.

Click through for detailed, step-by-step instructions on how to do this.

John Mount points out that there is a built-in function to mutate data frames in R:

The notation we used above is the “explicit argument” variation we recommend for readability. What a lot of

`dplyr`

users do not seem to know is: base-`R`

already has this functionality. The function is called`transform()`

.To demonstrate this, let’s first detach

`dplyr`

to show that we are not using functions from`dplyr`

.`detach("package:dplyr", unload = TRUE)`

Now let’s write the equivalent pipeline using exclusively base-

`R`

.

Click through for the way to do this as a pipeline operation.

Dave Mason continues his look at lists in R:

Subsetting the list with single brackets [] for the first element returns “Atlantic”. But if we take a closer look using the str() function, we see R returned the data as a class of type list:

> #Appears to return "Atlantic" as a character class. > division[1] $Name [1] "Atlantic" > #str shows us the return is actually a list of 1 element. > str(division[1]) List of 1 $ Name: chr "Atlantic"

Dave also explains the difference between single brackets and double brackets for list elements.

Now we can see not only when Arsenal picked up points, but when they dropped points as well. For example, on the 27th of August, they got beat by 4 goals as their goal difference shifted from 0 to -4.

We’re not done there! For the gif, we want to be able to display the current status of the team on each day i.e. Champions League (4th or above), Europa League (5th – 7th), Top Half (8th – 10th), Bottom Half (11th – 17th) or Relgations Zone (18th or below). To do this, on each day, we first need to retrieve the order of each team based on their points and goal difference

Click through to see the example.

John Mount has a new R tip, this time around passing a formula and seeing that formula later:

This works, and the

`paste()`

pattern is so useful we suggest researching and memorizing it.However the “call” portion of the model is reported as “

`formula = f`

” (the name of the variable carrying the formula) instead of something more detailed. Frankly this printing issue never bothered us. None of our tools or workflows currently use the model`call`

item, and for a very large number of variables formatting the call contents in the model report becomes unweildy. We also already have the formula in a variable, so if we need it we can save it or pass it along.There is a much better place on many models to get model structure information from than the model

`call`

item: the model`terms`

item. This item carries a lot of information and formats up quite nicely:format(terms(model)) # [1] "mpg ~ cyl + disp + hp + carb"

Be sure to check out the comments too, as there are several solutions to this problem.

Dave Mason continues his process of learning about R data structures with a survey of lists:

In previous lessons, we’ve noted vectors and matrices consist of data elements of the same class. R will coerce data elements to a single class if we attempt to create a vector or matrix with data elements of differing classes. Lists, on the other hand, can hold data elements of different classes, such as the integer, character, or logical class. In fact, a list can hold most anything in R, including vectors, matrices, and many more! None to my surprise, lists can be created with the list() function:

And if you want to work with lists, purrr is a great package to learn.

Here is an (artificial) example.

chamber_sizes <- mtcars$disp/mtcars$cyl form <- hp ~ chamber_sizes model <- lm(form, data = mtcars) print(model) # Call: # lm(formula = form, data = mtcars) # # Coefficients: # (Intercept) chamber_sizes # 2.937 4.104Notice: one of the variables came from a vector in the environment, not from the primary

`data.frame`

.`chamber_sizes`

was first looked for in the`data.frame`

, and then in the environment the`formula`

was defined (which happens to be the global environment), and (if that hadn’t worked) in the executing environment (which is again the global environment).Our advice is: do not do that. Place all of your values in columns. Make it unambiguous all variables are names of columns in your

`data.frame`

of interest. This allows you to write simple code that works over explicit data. The style we recommend looks like the following.

Read the whole thing.

David Smith walks us through various ways to integrate R and Excel:

If you’re familiar with analyzing data in Excel and want to learn how to work with the same data in R, Alyssa Columbus has put together a very useful guide: How To Use R With Excel. In addition to providing you with a guide for installing and setting up R and the RStudio IDE, it provide a wealth of useful tips for working with Excel data in R, including:

To import Excel data into R, use the readxl package

To export Excel data from R, use the openxlsx package

How to remove symbols like “$” and “%” from currency and percentage columns in Excel, and convert them to numeric variables suitable for analysis in R

How to do computations on variables in R, and a list of common Excel functions (like RAND and VLOOKUP) with their R equivalents

How to emulate common Excel chart types (like histograms and line plots) using R plotting functions

David also shows how to run R within Excel. One of the big benefits of `readxl`

is that it doesn’t require Java; most other Excel readers do.

Kevin Feasel

2018-09-19

Data Science, R

No Comment