forked from cjbarrie/CTA-ED
-
Notifications
You must be signed in to change notification settings - Fork 1
/
00-intro.Rmd
181 lines (103 loc) · 8.9 KB
/
00-intro.Rmd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
# Introduction to R {.unnumbered}
This section is designed to ensure you are familiar with the <tt>R</tt> environment.
## Getting started with R at home
Given that we're all working from home these days, you'll need to download R and RStudio onto your own devices. R is the name of the programming language that we'll be using for coding exercises; RStudio is the IDE ("Integrated Development Environment"), i.e., the piece of software that almost everyone uses when working in R.
You can download both of these on Windows and Mac easily and for free. This is one of the first reasons to use an "open-source" programming language: it's free and everyone can contribute!
IT Services at the University of Edinburgh have provided a [walkthrough](https://uoe.sharepoint.com/sites/hss/sps/itservices/SPSShareSpaceManagement/Moblabdoc/SitePages/Computational-Text-Analysis.aspx?cid=59b29656-3df8-4c19-9423-24765076e742) of what is needed for you to get started. I also break this down below:
1. Install R for Mac from here: https://cran.r-project.org/bin/macosx/. Install R for Windows from here: https://cran.r-project.org/bin/windows/base/.
2. Download RStudio for Windows or Mac from here: https://rstudio.com/products/rstudio/download/, choosing the Free version: this is what most people use and is more than enough for all of our needs.
**All programs are free. Make sure to load everything listed above for your operating system or R will not work properly!**
## Some basic information
+ A script is a text file in which you write your commands (code) and comments.
+ If you put the <tt>#</tt> character in front of a line of text this line will not be executed; this is useful to add comments to your script!
+ <tt>R</tt> is case sensitive, so be careful when typing.
+ To send code from the script to the console, highlight the relevant line of code in your script and click on <tt>Run</tt>, or select the line and hit <tt>ctrl+enter</tt> on PCR or <tt>cmd+enter</tt> on Mac
+ Access help files for <tt>R</tt> functions by preceding the name of the function with <tt>?</tt> (e.g., <tt>?table</tt>)
+ By pressing the <tt>up</tt> key, you can go back to the commands you have used before
+ Press the <tt>tab</tt> key to auto-complete variable names and commands
## Getting Started in RStudio
Begin by opening RStudio (located on the desktop). Your first task is to create a new script (this is where we will write our commands). To do so, click:
```{r eval=FALSE}
File --> NewFile --> RScript
```
Your screen should now have four panes:
+ the Script (top left)
+ the Console (bottom left)
+ the Environment/History (top right)
+ Files/Plots/Packages/Help/Viewer (bottom right)
## A simple example
The Script (top left) is where we write our commands for R. You can try this out for a first time by writing a small snipped of code as follows:
```{r, eval=TRUE}
x <- "I can't wait to learn Computational Text Analysis" #Note the quotation marks!
```
To tell R to run the command, highlight the relevant row in your script and click the <tt>Run</tt> button (top right of the Script) - or hold down <tt>ctrl+enter</tt> on Windows or <tt>cmd+enter</tt> on Mac - to send the command to the Console (bottom left), where the actual evaluation and calculations are taking place. These shortcut keys will become very familiar to you very quickly!
Running the command above creates an object named ‘x’, that contains the words of your message.
You can now see ‘x’ in the Environment (top right). To view what is contained in x, type in the Console (bottom left):
```{r eval=TRUE}
print(x)
# or alternatively you can just type:
x
```
## Loading packages
The 'base' version of <tt>R</tt> is very powerful but it will not be able to do everything on its own, at least not with ease. For more technical or specialized forms of analysis, we will need to load new packages.
This is when we will need to install a so-called ‘package’---a program that includes new tools (i.e., functions) to carry out specific tasks. You can think of them as 'extensions' enhancing <tt>R</tt>'s capacities.
To take one example, we might want to do something a little more exciting than print how excited we are about this course. Let's make a map instead.
This might sound technical. But the beauty of the packaged extensions of <tt>R</tt> is that they contain functions to perform specialized types of analysis with ease.
We'll first need to install one of these packages, which you can do as below:
```{r, eval=FALSE}
install.packages("tidyverse")
```
After the package is installed, we then need to load it into our environment by typing <tt>library(<insert name of package here>)</tt>. Note that, here, you don't need to wrap the name of the package in quotation marks. So this will do the trick:
```{r, eval=T}
library(tidyverse)
```
What now? Well, let's see just how easy it is to visualize some data using <tt>ggplot</tt> which is a package that comes bundled into the larger <tt>tidyverse</tt> package.
```{r, eval=T}
ggplot(data = mpg) +
geom_point(mapping = aes(x = displ, y = hwy))
```
If we wanted to save where we'd got to with making our plots, we would want to save our scripts, and maybe the data we used as well, so that we could return to it at a later stage.
## Saving your objects, plots and scripts
* Saving scripts: To save your script in RStudio (i.e. the top left panel), all you need to do is click File –> Save As (and choose a name for your script). Your script will be something like: myfilename.R.
* Saving plots: If you have made any plots you would like to save, click Export (in the plotting pane) and choose a relevant file extension (e.g. .png, .pdf, etc.) and size.
+ To save **individual** objects (for example <tt>x</tt> from above) from your environment, run the following command (choosing a suitable filename):
```{r, eval=FALSE}
save(x,file="myobject.RData")
load(file="myobject.RData")
```
+ To save **all** of your objects (i.e. everything in the top right panel) at once, run the following command (choosing a suitable filename):
```{r, eval=FALSE}
save.image(file="myfilname.RData")
```
+ Your objects can be re-loaded into R during your next session by running:
```{r, eval=FALSE}
load(file="myfilename.RData")
```
There are many other file formats you might use to save any output. We will encounter these as the course progresses.
## Knowing where R saves your documents
If you are at home, when you open a new script make sure to check and set your working directory (i.e. the folder where the files you create will be saved). To check your working directory use the getwd() command (type it into the Console or write it in your script in the Source Editor):
```{r, eval=FALSE}
getwd()
```
To set your working directory, run the following command, substituting the file directory of your choice. Remember that anything following the `#’ symbol is simply a clarifying comment and R will not process it.
```{r, eval=FALSE}
## Example for Mac
setwd("/Users/Documents/mydir/")
## Example for PC
setwd("c:/docs/mydir")
```
## Practicing in R
The best way to learn <tt>R</tt> is to use it. These workshops on text analysis will not be the place to become fully proficient in <tt>R</tt>. They will, however, be a chance to conduct some hands-on analysis with applied examples in a fast-expanding field. And the best way to learn is through doing. So give it a shot!
For some further practice in the R programming language, look no further than @wickham_r_2017 and, for tidy text analysis, @silge_text_2017.
- The free online book by Hadley Wickham "R for Data Science" is available [here](https://r4ds.had.co.nz/)
- The free online book by Julia Silge and David Robinson "Text Mining with R" is available [here](https://www.tidytextmining.com/)
- For more practice with R, you may want to consult a set of interactive tutorials, available through the package "learnr." Once you've installed this package, you can go through the tutorials yourselves by calling:
```{r, eval = F}
library(learnr)
available_tutorials() # this will tell you the names of the tutorials available
run_tutorial(name = "ex-data-basics", package = "learnr") #this will launch the interactive tutorial in a new Internet browser window
```
## One final note
Once you've dipped into the "R for Data Science" book you'll hear a lot about the so-called <tt>tidyverse</tt> in R. This is essentially a set of packages that use an alternative, and more intuitive, way of interacting with data.
The main difference you'll notice here is that, instead of having separate lines for each function we want to run, or wrapping functions inside functions, sets of functions are "piped" into each other using "pipe" functions, which look have the appearance: `%>%`.
I will be using "tidy" syntax in the weekly exercises for these computational text analysis workshops. If anything is unclear, I can provide the equivalents in "base" R too. But a lot of the useful text analysis packages are now composed with 'tidy' syntax.