R Project for Statistical Computing

https://www.r-project.org
Admin
R is a free software environment for statistical computing and graphics that compiles and runs on...
Tokens:443,064
Snippets:3,882
Trust Score:9.9
Update:10 months ago
Show doc for...
Tokens:
Raw
### Start R Online Documentation with help.start()

Source: https://www.r-project.org/help

help.start() launches a hypertext-based version of R's online documentation in the default web browser. This interface provides access to locally installed R manuals, a list of installed packages, and other documentation resources.

```R
help.start()
```

--------------------------------

### Installing R on Debian

Source: https://www.r-project.org/conferences/useR-2010/slides/Zolot_1

This section provides commands for installing R on Debian-based systems. It includes searching for available R packages, adding a CRAN mirror to the `sources.list` file, and then updating the package list and installing `r-base` and `r-base-dev`.

```bash
apt-cache search ^r-.*
#should get you started with a list of available packages.

#add to the file /etc/apt/sources.list on your computer line 
deb http://cran.mtu.edu/bin/linux/debian lenny-cran/

#or other CRAN  mirror URLs listed in  http://cran.r-project.org/mirrors.html


# After installing R 2.11.0 from CRAN, you will have to update or reinstall all 
# R packages that have been installed with an R version lower than R 2.10.X

apt-get update
apt-get install r-base r-base-dev
```

--------------------------------

### Accessing R Function Documentation

Source: https://www.r-project.org/help

This snippet shows how to access documentation for R functions, data sets, and other objects using the `help()` function or the `?` operator. It covers accessing documentation for loaded and unloaded packages, as well as objects with non-standard names. The `example()` function can be used to run executable examples from help pages.

```R
help(lm)
?lm
help("lm")
?"lm"
help(rlm, package="MASS")
help('?')
?"?"
help(package="MASS")
example(lm)
```

--------------------------------

### Online Data Collection with RSelenium and Rvest

Source: https://www.r-project.org/conferences/useR-2018/tutorials/index

This guide focuses on combining RSelenium and Rvest libraries in R for effective online data collection. It provides details on installation and setup, enabling users to scrape and extract data from web pages.

```r
install.packages("RSelenium")
install.packages("rvest")

library(RSelenium)
library(rvest)

# Example: Using rvest to scrape a webpage
# url <- "http://example.com"
# page <- read_html(url)

# Extracting data (e.g., all paragraphs)
# paragraphs <- html_nodes(page, "p") %>%
#   html_text()

# print(paragraphs)

# Example: Using RSelenium to interact with a browser (requires a WebDriver, e.g., ChromeDriver)
# remDr <- remoteDriver(remoteServerAddr = "localhost", port = 4444L, browserName = "chrome")
# remDr$open()
# remDr$navigate("http://quotes.toscrape.com/")

# Get page source
# page_source <- remDr$getPageSource()[[1]]
# web_page <- read_html(page_source)

# Extract quotes and authors
# quotes <- html_nodes(web_page, "span.text") %>%
#   html_text()
# authors <- html_nodes(web_page, "small.author") %>%
#   html_text()

# df <- data.frame(quote = quotes, author = authors)
# print(df)

# remDr$close()

```

--------------------------------

### Deploy R Applications with Docker

Source: https://www.r-project.org/conferences/useR-2018/tutorials/index

This section focuses on building and deploying R applications as stand-alone Docker containers. It covers scenarios like using Shiny, databases, plumber, and keras within Docker, with potential for cloud deployment and scaling using Kubernetes. Participants should have some prior exposure to Docker.

```dockerfile
FROM r-base

# Install R packages
RUN R -e "install.packages(c('shiny', 'jsonlite', 'plumber', 'keras'))"

# Copy application code
COPY ./app /srv/shiny-server/

# Expose Shiny port
EXPOSE 3838

# Start Shiny server
CMD ["R", "-e", "shiny::runApp('/srv/shiny-server')"]
```

```r
# Example R script to be run within Docker
library(shiny)

ui <- fluidPage(
  titlePanel("My Shiny App")
)

server <- function(input, output) {
  output$distPlot <- renderPlot({
    hist(rnorm(input$obs))
  })
}

shinyApp(ui = ui, server = server)
```

--------------------------------

### Bundling and Uploading EC2 Volumes to S3

Source: https://www.r-project.org/conferences/useR-2010/slides/Zolot_1

This section provides instructions for bundling an EC2 volume into an AMI and uploading it to S3. It involves installing EC2 AMI tools, bundling the volume using `ec2-bundle-vol`, and uploading it using `ec2-upload-bundle`. The process requires AWS credentials and an S3 bucket.

```bash
# apt-get install unzip 

#Download the Amazon AMI tools onto the instance.

mkdir ~/ec2
cd ~/ec2
wget http://s3.amazonaws.com/ec2-downloads/ec2-ami-tools.zip 
unzip ec2-ami-tools.zip
ln -s ec2-ami-tools-* current
vi ~/.bashrc
#add the following lines to the end of the .bashrc file

export EC2_AMITOOL_HOME=~/ec2/current
export PATH=${PATH}:~/ec2/current/bin
#And then re-initialise the configuration file

source ~/.bashrc
#should be able to run w/o error:

# ec2-bundle-vol --help

#Create your AMI.. While still on the server run the following command:

ec2-bundle-vol -d /mnt -k /mnt/pk-STRINGOFTHIRTYTWOLETTERSORDIGITS.pem -c /mnt/cert-STRINGOFTHIRTYTWOLETTERSORDIGITS.pem -u XXXXXXXXXXXX
# XXXXXXXXXXXX is your Amazon account number without the dashes.
# wait 15 min :(

#Save your new AMI to S3.

ec2-upload-bundle -b [your-s3-bucket] -m /mnt/image.manifest.xml -a [aws-access-key-id] -s [aws-secret-access-key]
#If the bucket doesn’t exist, it should create the bucket for you though. The keys are those crazy long keys you use to access S3.

#== Register the AMI via GUI or command tool 
#Go back to your desktop, and issue the command:

ec2-register [your_bucket]/image.manifest.xml
```

--------------------------------

### Get Package Description in R

Source: https://www.r-project.org/bugs

This R function retrieves detailed description information for a given package. This includes fields like 'BugReports' which can direct you to the correct submission portal. Requires the package to be installed.

```R
packageDescription("somePkg")
```

--------------------------------

### Get Package Maintainer Information in R

Source: https://www.r-project.org/bugs

This R function retrieves the maintainer information for a specified package. It's a crucial step in identifying who to contact for package-specific bugs. Ensure the 'maintainer' package is installed.

```R
maintainer("graphics")
```

--------------------------------

### DALEX: Machine Learning Model Explanations

Source: https://www.r-project.org/conferences/useR-2018/tutorials/index

This tutorial introduces the DALEX library in R for exploring, validating, and explaining complex machine learning models. It covers techniques for understanding black-box models, including conditional and local explainers (PDP, ICE, Break Down plots), and global explainers (variable importance).

```r
install.packages(c("DALEX", "breakDown", "live", "auditor", "randomForest", "ceterisParibus"))

library(DALEX)
library(randomForest)
library(xgboost)
library(mlr)

# Example: Fitting a random forest model
# Assuming you have a data frame 'data' and a target variable 'target'
# model_rf <- randomForest(target ~ ., data = data)

# Create an explainer object
# explainer_rf <- explain(model_rf, data = data, y = data$target)

# Example: Partial Dependence Plot (PDP)
# pdp_var <- predict_profile(explainer_rf, variables = "feature_name")
# plot(pdp_var)

# Example: Break Down plot for a single prediction
# prediction_id <- 1 # Index of the observation to explain
# bd_single <- break_down(explainer_rf, data[prediction_id, ], keep_distributions = TRUE)
# plot(bd_single)
```

--------------------------------

### Uploading and Reading Data Files

Source: https://www.r-project.org/conferences/useR-2010/slides/Zolot_1

This example illustrates how to write a data frame to a local file and then read it back. It also shows how to read data from a file on a remote system, likely for processing and analysis, including generating plots and performing cluster analysis.

```r
# local ===
n=100
x= data.frame(x1= sample(2,n, replace = T) + rnorm(n, 0, .1)
            , x2= sample(2,n, replace = T) + rnorm(n, 0, .3))
plot(x2~x1, data=x)
write.table(x, 'Z:/work/29_Conferences/1101_R/x.txt')
y= read.table('Z:/work/29_Conferences/1101_R/x.txt')

# remote ===


pdf('clus.pdf')
y= read.table('x.txt')

attach(y)
plot(x2~x1)

install.packages("cluster", repos = "http://cran.stat.ucla.edu/")
library(cluster)

pamr <- pam(y, k=4)
pamc <- pamr$clustering

plot(x1, x2, col=pamc)
#clusplot(pamr, color=TRUE, col.clus = 1:4, shade = TRUE, axes=T, labels=0) #  names(pamr$ clustering))
clusplot(pamr, color=TRUE, col.clus = 1:4, shade = TRUE, labels=0) #  names(pamr$ clustering))

dev.off()
```

--------------------------------

### Test Rcpp Setup with C++ Code Execution in R

Source: https://www.r-project.org/conferences/useR-2018/tutorials/index

This R snippet demonstrates a simple test to verify the Rcpp setup by evaluating a C++ expression directly within R. It uses the `Rcpp::evalCpp()` function. A successful execution returning '42' indicates that Rcpp is correctly installed and configured to compile and run C++ code.

```R
R> Rcpp::evalCpp("6 * 7")
[1] 42
```

--------------------------------

### Test Docker Installation

Source: https://www.r-project.org/conferences/useR-2018/tutorials/index

These commands are used to verify if Docker is installed correctly on a system. The first command runs a simple test container, and the subsequent commands pull RStudio-related Docker images.

```shell
docker run hello-world
```

```shell
docker pull rocker/studio
```

```shell
docker pull rocker/geospatial
```

--------------------------------

### Getting System Locale Information

Source: https://www.r-project.org/posting-guide

This R command displays the current system locale settings. This information can be relevant when diagnosing issues related to character encoding, date/time formatting, or other locale-specific behaviors.

```r
Sys.getlocale()
```
Tokens:
Raw