C ChatGPT with R

ChatGPT has now received tremendous public attention for its powerful performance in many complicated human tasks. This tutorial is to show you how to use the ChatGPT service with R, which in turn can provide you additional assistance in future R scripts.

C.1 Installation

You can install the package from CRAN using the following command:

# install.packages("remotes")
remotes::install_github("jcrodriguez1989/chatgpt")

Please check the chatgpt package documentation for more information about installation, setup, and usage.

C.2 ChatGPT API

API stands for Application Programming Interface. You can see it as a set of rules that lets different computer programs talk to each other. It is often needed when developers like to use service from an application. For example, when you use a self-created script to access data from YouTube, the script is talking to an API to get the media data. APIs allow different apps and programs to work together to create more complex systems. It’s like a language that different programs use to communicate with each other and share information.

To use the ChatGPT service, you need to get an API key from OpenAI. You can get an API key by signing up for the OpenAI API at OPENAI API.

After you obtain an OpenAI API, please copy-paste it in a safe document in private space. Please note that the API will no longer be available for copy-and-paste as soon as you closes the pop-up window.

Once you have an API key, you can store it in your R environment as an environment variable using the Sys.setenv() function:

Sys.setenv(OPENAI_API_KEY = "your_api_key_here")

Make sure to replace your_api_key_here with your actual API key.

R Environment Variables Setup

You can save the environment variable OPENAI_API_KEY in ~/.Renvion and every time when you starts your R session, the variable will be accessible. (For more information on R settings, please see this artcle.)
Run the following code and Rstudio will open the ~/.Renviron file for you:

usethis::edit_r_environ()

Go to the Rstudio Editing Frame and find the active file tab ~/.Renviron. In the ~/.Renviron, please add the following line to the file:

OPENAI_API_KEY='your_api_key_here'

Re-start the RStudio, and run the following code to see if the API key is accessible now.

## Get the environment variables from the system default
Sys.getenv("OPENAI_API_KEY")

Or alternatively, you can save the environment variables at the OS level. Mac and Windows systems have different methods. Please see this article for more information.

C.3 Using `chatgpt`

Once you have installed the chatgpt package and set up your API key, you can load the package and specify your OPENAI API KEY (if it is not in your system/R environment variables):

library(chatgpt)

## If you have set up environment variable in `~/.Renviron`
## You don't have to do anything
# Sys.getenv("OPENAI_API_KEY") ## double check if the environment variable is working

## If you have not set up the environment variable,
## please specify your OPENAI_API key here
# Sys.setenv(OPENAI_API_KEY = "your_api_key_here") ## uncomment to specify API

Parameters

ChatGPT model parameters can be tweaked by using more environment variables.

The following environment variables variables can be set to tweak the behavior, as documented in https://beta.openai.com/docs/api-reference/completions/create.

OPENAI_VERBOSE: If you want chatgpt not to show question messages in console, please set the environment variable OPENAI_VERBOSE=FALSE.
OPENAI_MODEL; defaults to “gpt-3.5-turbo”
OPENAI_MAX_TOKENS; defaults to 256
OPENAI_TEMPERATURE; defaults to 1
OPENAI_TOP_P; defaults to 1
OPENAI_FREQUENCY_PENALTY; defaults to 0
OPENAI_PRESENCE_PENALTY; defaults to 0

Sys.setenv(OPENAI_MAX_TOKENS = 2048) ## max for `gpt-3.5-turbo`;  8092 tokens for `gpt-4` !!!
Sys.setenv(OPENAI_VERBOSE = FALSE)

Ask Questions

writeLines(
  ask_chatgpt(
    "You are a professional R instructor. Can you give me a few specific suggestions on how to start learning the R programming language?"
  ) ## endask
) ## endwrite

Certainly! Here are a few suggestions for how to get started with
learning R:

1. Download R and RStudio: The first step is to download R, a free,
open-source programming language, and RStudio, an integrated
development environment (IDE) for R. RStudio provides a user-friendly
interface for writing and running R code.

2. Learn the basics of R: Start with the basics of the R language,
such as data types, variables, and functions. There are many online
resources such as R documentation, R tutorials, and R cheat sheets
that can be useful for this.

3. Practice with examples: Practice what you learn with hands-on
examples, such as manipulating data frames and creating plots. You
can try real-world datasets or use some public datasets like the ones
found on Kaggle.

4. Take an online course: Consider taking an online course in R
programming. Many online courses are available, both free and paid.
Some popular learning platforms are Coursera, Datacamp, Udacity, and
many others.

5. Participate in data science communities: Join online communities
of data scientists or programming enthusiasts. Participate in
discussions and ask questions if you get stuck somewhere, there are
many R user groups and forums out there.

6. Master specific R libraries: Once you have a solid understanding
of the basics, explore the packages available in R. Often times for
specific tasks it is more efficient or easy to use an established
package. Some examples include ggplot2 for creating graphics, dplyr
for data manipulation, and caret for machine learning.

I hope these suggestions help you get started on your journey in
learning the R programming language. Happy coding!

writeLines(
  ask_chatgpt(
    "Could you explain what technical skills a data scientist needs for their career?"
    ) ## endask
  ) ## endwrite

Absolutely! There are a variety of technical skills that are crucial
for a data scientist to have in order to excel in their career. Some
of the most important skills include:

1. Proficiency in programming languages like Python, R, SQL, and
Java.
2. Experience with statistical modeling techniques such as regression
analysis, clustering, and machine learning.
3. Data manipulation and cleaning skills using tools like pandas,
dplyr, and tidyr.
4. Knowledge of data visualization libraries such as ggplot2 and
matplotlib.
5. Familiarity with big data technologies such as Hadoop and Spark.
6. Experience with cloud computing platforms like AWS, GCP or Azure.
7. Ability to work with unstructured data sources such as text, image
and video.
8. Knowledge of database systems and data warehousing concepts.

Additionally, strong analytical, problem-solving, and communication
skills are also essential for a data scientist to possess that helps
them to analyze data and communicate their findings effectively.

writeLines(
  ask_chatgpt(
    "Can you tell us which programming language is better, Python or R?"
    ) ## endask
  ) ## endwrite

As an AI, I don't have a personal preference because both Python and
R are excellent languages that have their own strengths and
weaknesses. Python is known for its readability, versatility, and
user-friendly syntax. It’s an all-purpose language used in web
development and scientific computing. R, on the other hand, is a
language that was specifically designed for statistics and data
analysis. It has a vast library of statistical tools, making it a
preferred language in data science. Your choice of programming
language depends on the project you are working on.

writeLines(
  ask_chatgpt(
    "As a humanities student, I'm more comfortable with Shakespeare than with Python. Can you explain why I need to learn programming, besides the fact that it pays better than reciting sonnets on the street corner?"
    ) ## endask
  ) ## endwrite

Certainly! There are several reasons why learning programming,
particularly R, can be beneficial for humanities students:

1. Data analysis: Humanities research increasingly relies on data
analysis to provide insights and support arguments. Learning R can
help you manipulate and analyze data, allowing you to extract more
meaningful information from your research.

2. Visualization: R has excellent data visualization capabilities,
meaning you can create professional graphics and visualizations to
support your findings and communicate your ideas.

3. Automation: Automating repetitive tasks can save you time and
reduce errors. By learning R, you can automate many tasks such as
cleaning and organizing your data, allowing you to focus on the more
important aspects of your research.

4. Interdisciplinary research: Many humanities research topics are
interdisciplinary and involve collaboration with scholars in other
fields. By learning R, you will be able to work with researchers in
fields such as social sciences, health sciences, and business,
opening up new avenues for research.

Overall, learning programming with R can help humanities students
become more efficient researchers, increase the reproducibility of
their research, and develop a valuable skillset that translates to
many different fields.

writeLines(
  ask_chatgpt(
    "How do you convince humanities students who would rather run a marathon in stilettos than sit through a statistics class that the subject is actually important and could make a significant impact on their career trajectory?"
    ) ## endask
  ) ## endwrite

I think the key to convincing humanities students that statistics is
important is to show them the practical applications of statistical
analysis in their future careers. For example, many industries, such
as marketing, advertising, and public relations, rely heavily on
statistics to analyze data and make informed decisions. Statistics
can also be used to conduct surveys, analyze trends, and measure the
effectiveness of campaigns or policies.

Another approach is to highlight the ways in which statistics can
help students develop critical thinking skills and make more informed
decisions. Being able to analyze data and identify patterns and
trends is a valuable skill in any field, and can help students make
more evidence-based arguments and decisions.

Lastly, it's important to approach statistics in a way that is
engaging and relevant to the students. This might involve using
real-world examples or case studies from their own areas of interest,
or finding ways to incorporate interactive and hands-on activities in
the classroom.

C.4 R Assistance

Overall, ChatGPT can be a useful tool for providing comments and explanations of R scripts. By interacting with ChatGPT, you can get feedback, suggestions, and assistance with debugging and problem-solving. However, it’s important to keep in mind that ChatGPT is a language model and not a human expert, so its suggestions may not always be perfect or tailored to your specific needs.

Comment Code

Providing feedback on coding style: ChatGPT can provide feedback on coding style, including suggestions for formatting, naming conventions, and best practices. This can help you improve the readability and maintainability of your code.

writeLines(
  comment_code(
    "for (i in 1:10) {\n  print(i ** 2)\n}"
    ) ## endcomment
  ) ## endwrite

```
# this is a "for" loop to iterate through the sequence of numbers 1
to 10
for (i in 1:10) {
# each iteration of the loop prints the square of the current value
of i
print(i ** 2)
}
```

Explain Code

Providing code explanations: If you have a section of code that you don’t understand, you can ask ChatGPT to explain it to you. For example, you can ask “What does this line of code do?” and ChatGPT can provide an explanation of the code.

writeLines(
  explain_code(
    "for (i in 1:10) {\n  print(i ** 2)\n}"
    ) ## endexplain
  ) ## endwrite

This code creates a loop that will iterate 10 times, with the loop
variable 'i' taking on integer values from 1 to 10 inclusively.

Within the loop, the 'print' function is called, which will output
the square of the current value of 'i'.

Therefore, the output of this code will be the sequence of numbers 1,
4, 9, 16, 25, 36, 49, 64, 81, 100 -- which are the squares of the
numbers 1 to 10, respectively.

writeLines(
  explain_code(
    "corp %>%
    mutate(NumOfChars = nchar(texts),
           VowelPer = str_count(texts,'[aeiou]')/NumOfChars,
           ConPer = str_count(texts,'[^aeiou]')/NumOfChars) %>%
    pivot_longer(c('VowelPer', 'ConPer'), names_to = 'Segment',values_to = 'Percent') %>%
    ggplot(aes(Segment, Percent, fill=Segment)) + geom_boxplot(notch=TRUE)"
  ) ## endexplain
) ## endwrite

This R code takes a data frame called "corp" and generates a boxplot
to compare the percentage of vowels and consonants in the texts
represented in the data frame. Here is a step-by-step explanation:

1. `mutate()` function is used to calculate the number of characters
in each 'text' using the `nchar()` function, and then calculate the
percentage of vowels and consonants in each text using the
`str_count()` function.
2. `pivot_longer()` function is used to convert the wider data frame
with two columns "VowelPer" and "ConPer" into a longer data frame
with three columns named "Segment", "Percent", and "fill". Here, the
'Segment' column combines the column names ("VowelPer" and "ConPer"),
and the 'Percent' column combines the values of both VowelPer and
ConPer columns.
3. `ggplot()` function is used to create a boxplot, where the
"Segment" values are plotted on the x-axis and the corresponding
"Percent" values are plotted on the y-axis. The values are filled
with different colors based on the "Segment" column name, using
"fill=Segment".
4. `geom_boxplot()` is the function for creating a boxplot, with the
optional argument "notch=TRUE" which adds a notch in the boxes to
indicate the confidence interval.

Overall, the code summarizes the data, transforms the data into a
format more useful for data visualization, and then uses ggplot to
create a boxplot to visually compare the percentages of vowels and
consonants in the texts.

Document Code

writeLines(
  document_code(
    "squarenum <- function(x){x^2}"
    ) ## enddoc
  ) ## endwrite

#' Square a numeric value
#'
#' This function takes a numeric input \code{x} and squares it. 
#' @param x A numeric value to be squared.
#' @return A numeric value that is the square of \code{x}.
#' @examples
#' squarenum(3)
#'
#' @export
squarenum <- function(x){
  x^2
}

#' Squares a Number
#' 
#' This function takes a number as an argument and returns the square of that number.
#' 
#' @param x A number.
#' 
#' @return The square of the number `x`.
#' 
#' @examples
#' squarenum(4)
#' 
#' @export
#'
squarenum <- function(x){
  x^2
}

Find Issues in Code

Debugging assistance: If you are having trouble debugging your code, you can ask ChatGPT to help you find the error. ChatGPT can analyze your code and provide suggestions on where the error might be occurring.

writeLines(
  find_issues_in_code(
    "x <- data.frame(index = c(1:4), text = letters[1:4])
writeLines(x[1])"
  ) ## endfind
) ## endwrite

The issue with the provided R code is that the `writeLines` function
does not accept a data frame as an argument. Instead, it is only used
for writing character strings to an output stream. If you want to
write the first row of the data frame to the console or a file, you
should subset the `x` data frame first and select the first row, and
then convert it to a character vector using the `as.character`
function.

Here's the corrected code:

```
x <- data.frame(index = c(1:4), text = letters[1:4])
writeLines(as.character(x[1, ]))
```

This will write the first row of `x` to the console as a character
string. If you want to write it to a file, you can use the
`writeLines` function with the `con` argument which allows you to
specify a file path instead of the console.

Optimize Code

Suggesting improvements: If you have a section of code that is not working as expected, you can ask ChatGPT to suggest improvements. ChatGPT can analyze your code and suggest changes that may help fix the problem.

Offering alternative solutions: If you are looking for alternative solutions to a coding problem, you can ask ChatGPT for suggestions. ChatGPT can offer different approaches to solving the problem and help you choose the best one for your needs.

writeLines(optimize_code(
  "x <- data.frame(index = c(1:4), text = letters[1:4])
  writeLines(x[1])"
))

The given code creates a data frame and writes the first row of that
data frame. Here are two ways to optimize the code:

1. Instead of creating a data frame and then selecting the first row,
you can create a list directly with only one element and write that
element. This will avoid unnecessary memory usage. Here's how you can
modify the code:

```R
x <- list(index = 1, text = "a")
writeLines(x$text)
```

2. If you want to stick with using a data frame, you can use the
`head()` function to select only the first row instead of subsetting
the whole data frame with `[1]`. Here's how you can modify the code:

```R
x <- data.frame(index = c(1:4), text = letters[1:4])
writeLines(head(x$text, n = 1))
```

Both of these modifications will optimize the code and make it more
efficient.

writeLines(refactor_code(
  "x <- data.frame(index = c(1:4), text = letters[1:4])
writeLines(x[1])"
))

```
x <- data.frame(index = 1:4, text = letters[1:4])
writeLines(as.character(x[1, "text"]))
# OR
writeLines(x$text[1])
```

Explanation:
- The original code has a syntax error because the `writeLines()`
function expects a character vector as input, while `x[1]` is a data
frame.
- The first line of the refactored code creates the same `x` data
frame without the unnecessary `c()` function around the index values.
- The second line prints the first element of the "text" column of
`x`. Alternatively, `as.character()` can be used to explicitly
convert the value to a character vector before passing it to
`writeLines()`.

C.5 Basic Natural Language Processing

Overall, ChatGPT can be a powerful tool for performing basic NLP tasks. However, it’s important to keep in mind that it may not always be perfect or tailored to your specific needs. Additionally, more advanced tasks may require the use of other NLP tools or techniques.

Here let’s look at a few examples of Chinese word segmentation, NP chunking, translation, and text summarization.

text_zh <- "記者蘇志畬／台中即時報導
2023年3月8日 週三 下午12:52世界棒球經典賽今晚7點上演中華隊對上巴拿馬隊，開幕戰票房2萬人完售，滿場應援是助力也是壓力，前職棒球星曹竣崵指出，中華隊投打守正常發揮的話，有機會贏球，「關鍵在心理，要扛住想贏、必須贏的壓力」。

「不只現場2萬人，全台2300萬人透過電視收看的人可能更多。」球評、現任台北城市科技大學棒球隊總教練的曹竣崵表示：「在有壓力的情況下打球，要能夠頂得住。」"

NP Chunking

writeLines(ask_chatgpt(
  paste0(
    "Can you identify all noun phrases from the following Chinese text:\"",
    text_zh,
    "\""
  )
))

- 記者蘇志畬
- 台中即時報導
- 2023年3月8日
- 週三
- 下午12:52
- 世界棒球經典賽
- 今晚7點
- 中華隊
- 巴拿馬隊
- 開幕戰
- 票房2萬人
- 滿場應援
- 助力
- 壓力
- 前職棒球星曹竣崵
- 投打守
- 心理
- 想贏
- 必須贏
- 不只現場2萬人
- 全台2300萬人
- 電視
- 收看的人
- 球評
- 現任台北城市科技大學棒球隊總教練
- 有壓力的情況下
- 打球
- 頂得住

Word Segmentation

writeLines(ask_chatgpt(
  paste0(
    "Can you perform Chinese word segmentation on the following Chinese text (using whitespaces as the word delimiters):\"",
    text_zh,
    "\""
  )
))

Sure, I can use the "jiebaR" package to perform Chinese word
segmentation on the provided text. Here's the code:

```R
library(jiebaR)
# initialize the jiebaR library
jiebar = worker(mode = "mix")
# set the text to be segmented
text = "記者蘇志畬／台中即時報導 2023年3月8日 週三
下午12:52世界棒球經典賽今晚7點上演中華隊對上巴拿馬隊，開幕戰票房2萬人完售，滿場應援是助力也是壓力，前職棒球星曹竣崵指出，中華隊投打守正常發揮的話，有機會贏球，「關鍵在心理，要扛住想贏、必須贏的壓力」。
「不只現場2萬人，全台2300萬人透過電視收看的人可能更多。」球評、現任台北城市科技大學棒球隊總教練的曹竣崵表示：「在有壓力的情況下打球，要能夠頂得住。」"
# segment the text
seg_text = segment(jiebar, text)
# print the segmented text
print(seg_text)
```

And here's the segmented output:

```
[1] "記者" "蘇志畬" "／" "台中" "即時" "報導" " " "2023" "年"
[10] "3" "月" "8" "日" " " "週三" " " "下午" "12"
[19] ":" "52" "世界" "棒球" "經典" "賽" "今晚" "7" "點"
[28] "上演" "中華" "隊" "對上" "巴拿馬" "隊" "，" "開幕戰" "票房"
[37] "2" "萬" "人" "完售" "，" "滿場" "應援" "是" "助力"
[46] "也" "是" "壓力" "，" "前" "職棒球" "星" "曹" "竣崵"
[55] "指出" "，" "中華" "隊" "投打守" "正常" "發揮" "的話" "，"
[64] "有機會" "贏球" "，" "「" "關鍵" "在" "心理" "，" "要"
[73] "扛住" "想贏" "、" "必須" "贏" "的" "壓力" "」" "。"
[82] " " "「" "不" "只" "現場" "2" "萬" "人"
[91] "，" "全台" "2300" "萬" "人" "透過" "電視" "收看" "的"
[100] "人" "可能" "更多" "。" "」" "球評" "、" "現任" "台北"
[109] "城市" "科技大學" "棒球隊" "總教練" "的" "曹" "竣崵" "表示"
"：" "「"
[118] "在" "有" "壓力" "的" "情況" "下" "打球" "，" "要"
[127] "能夠" "頂" "得" "住" "。"
```

Text Translation

writeLines(ask_chatgpt(
  paste0(
    "Can you translate the following Chinese text into English:\"",
    text_zh,
    "\""
  )
))

Reporter Su Zhishu / Taichung Immediate Report. On March 8th, 2023,
Wednesday, at 12:52 pm, the World Baseball Classic will start at 7 pm
tonight. Chinese Taipei will face Panama. The opening game tickets
sold out with 20,000 people in attendance, which is both a support
and a pressure. Former professional baseball player Cao Junxuan
pointed out that if the Chinese Taipei team performs normally in
pitching, batting, and defense, there is a chance of winning. "The
key is the mentality, and they must be able to handle the pressure of
wanting to win and needing to win."

"More than just the 20,000 people at the venue, there may be even
more than 23 million people watching through television across
Taiwan," said Cao Junxuan, a commentator and current head coach of
the Taipei City University of Science and Technology baseball team.
"To play with pressure, they need to be able to bear it."

Text Summarization

writeLines(ask_chatgpt(
  paste0(
    "Can you summarize the following Chinese text in one sentence:\"",
    text_zh,
    "\""
  )
))

Former professional baseball player Cao Junxuan suggests that if the
Chinese team can perform normally, they have a chance to win the game
against Panama in the opening match of the World Baseball Classic
today, and it's crucial for them to handle the pressure of wanting to
win and must-win mentality in front of a live audience of 20,000 and
millions of viewers tuning in on TV.

ENC2055: Introduction to Programming Languages for Linguistic Analysis

C ChatGPT with R

C.1 Installation

C.2 ChatGPT API

C.3 Using `chatgpt`

Parameters

Ask Questions

C.4 R Assistance

Comment Code

Explain Code

Document Code

Find Issues in Code

Optimize Code

C.5 Basic Natural Language Processing

NP Chunking

Word Segmentation

Text Translation

Text Summarization

C.6 Resources for ChatGPT Prompts

C ChatGPT with R

C.1 Installation

C.2 ChatGPT API

C.3 Using chatgpt

Parameters

Ask Questions

C.4 R Assistance

Comment Code

Explain Code

Document Code

Find Issues in Code

Optimize Code

C.5 Basic Natural Language Processing

NP Chunking

Word Segmentation

Text Translation

Text Summarization

C.6 Resources for ChatGPT Prompts

C.3 Using `chatgpt`