8 ChatGPT applications for R programming

Without having fine-tuning or staying educated on a certain matter, ChatGPT can answer questions about a huge variety of know-how subjects—including how to produce R code. That means ChatGPT’s power is readily available to any R programmer, even one who knows very little about huge language types. (A significant language product, or LLM, is the technologies underpinning AI chatbots like OpenAI’s ChatGPT.)

An ecosystem is forming around ChatGPT and R, creating it uncomplicated to integrate the AI engineering into your R language workflow. But just before you start off making use of ChatGPT and resources linked with it for assignments in R, there are a couple of vital things to keep in intellect:

1. Almost everything you talk to with these instruments receives sent to OpenAI’s servers. Really don’t use ChatGPT equipment to approach sensitive information and facts.
2. ChatGPT may confidently return solutions that are completely wrong. Even incorrect responses can be a time-saving starting level, but you should not think the code will do specifically what you assume. Kyle Walker, an affiliate professor at Texas Christian College and writer of the preferred tidycensus R package deal, recently tweeted that ChatGPT can “supercharge your perform if you recognize a subject nicely,” or it can depart you “exposed for not being aware of what you are accomplishing.” The change is in knowing when the AI output is not appropriate. Always check ChatGPT’s responses.
3. ChatGPT can make distinctive responses to the exact same query—and some responses may be exact although some others aren’t. For occasion, when I questioned many instances for a ggplot2 bar chart with blue bars, the code created a graph with blue bars sometimes but not other folks, even although I submitted the correct very same request. This is obviously much less than best if you need to have a reproducible workflow.
4. If there’s been a current update to a offer you happen to be applying, ChatGPT would not know about it, because its instruction knowledge finishes in 2021.
5. Most of the means in this write-up have to have you to have your personal OpenAI API crucial, and the API is just not absolutely free to use. Even though pricing is low at the second, you can find no assure it will keep that way. Present pricing is .2 cents per 10,000 tokens for the ChatGPT 3.5 turbo model. What does a token get you? As one example, the request to build a scatter plot from a 234-row mpg facts established price 38 tokens, a fraction of a cent.
6. Asking ChatGPT for coding assist is not likely to ensnare you in the ethics of AI racial and gender bias. However, there are heated conversations about the knowledge of furnishing OpenAI with nevertheless extra facts the ethics of how the schooling info was scraped and repurposed and if it is far better to use open up resource significant language styles (these types of as H2O.ai’s h2oGPT) rather than OpenAI’s. Those people dilemmas are for each individual specific and group to parse for them selves. On the other hand, as of this producing, there simply usually are not R-distinct LLM equipment that are comparable to these building up all around ChatGPT. 

Now, let’s glance at some of the most notable R-targeted ChatGPT assets at the moment out there.

RTutor

This app is an stylish and easy way to sample ChatGPT and R. Upload a knowledge established, request a query, and check out as it generates R code and your success, which include graphics. Although it truly is named RTutor, the app can also create Python code.

RTutor is on the web at https://rtutor.ai/. It is really presently the only application or deal shown that would not demand a ChatGPT API critical to use, but you happen to be asked to source your have for major use so as not to monthly bill the creators’ account.

Screenshot by Sharon Machlis

The app’s About web site describes that RTutor’s principal purpose “is to support men and women with some R knowledge to discover R or be more successful … RTutor can be utilised to speedily pace up the coding procedure making use of R. It offers you a draft code to check and refine. Be wary of bugs and glitches.”

The code for RTutor is open supply and available on GitHub, so you can put in your individual regional version. However, licensing only lets use of the app for nonprofit or non-professional use, or for business tests. RTutor is a private undertaking of Dr. Steven Ge, a professor of bioinformatics at South Dakota Condition College. 

CodeLingo

This multi-language application “translates” code from a single programming language to one more. Available languages include Java, Python, JavaScript, C, C++, PHP and extra, together with R.  This is a net application only, obtainable at https://analytica.shinyapps.io/codelingo/ . You need to have to enter your OpenAI API essential to use it (you could want to regenerate the essential soon after tests).

Screenshot by Sharon Machlis

A ask for to translate code for a ggplot2 R graph into JavaScript generated output employing the instead really hard-to-study D3 JavaScript library, as opposed to a thing a JavaScript beginner would be extra possible to want this sort of as Observable Plot or Vega-Lite.

The ask for to translate into Python, demonstrated in Determine 2, was much more clear-cut and made use of libraries I might be expecting. However, ChatGPT did not have an understanding of that “Established1” is a ColorBrewer colour palette and are not able to be employed instantly in Python. As is the situation for several ChatGPT works by using, translating code among programming languages may give you a helpful commencing issue, but you will need to know how to resolve blunders.

The application was developed by Analytica Details Science Alternatives.

askgpt

This offer, out there at https://github.com/JBGruber/askgpt, can be a good starting up level for to start with-time customers who want ChatGPT in their console, in aspect since it presents some guidance on first startup. Load the bundle with library(askgpt) and it responds with:

Hi, this is askgpt ☺.
• To begin mistake logging, run `log_init()` now.
• To see what you can do use `?askgpt()`.
• Or just run `askgpt()` with any question you want!

Use the login() operate with no to start with storing a vital, and you can expect to see a message on how to get an API critical:

ℹ It looks like you have not supplied an API key still.
1. Go to 
2. (Log into your account if you have not carried out so still)
3. On the web page, click the button + Build new secret critical to generate an API essential
4. Duplicate this essential into R/RStudio

You’ll be requested to help save your critical in your keyring, and then you happen to be all established for long run periods. If your crucial is previously saved, login() returns no concept.

askgpt‘s default is to shop results of your query as an item so you can save them to a variable like this one particular:

barchart_guidance <- askgpt("How do I make a bar chart with custom colors with ggplot2?")

Submit a query and you'll first see:

GPT is thinking ⠴ 

This way, you know your request has been sent and an answer should be forthcoming, instead of wondering what is happening after you hit submit.

Along with the package's general askgpt() function, there are a few coding-specific functions such as annotate_code(), explain_code(), and test_function(). These will involve cutting and pasting responses back into your source code.

For those familiar with the OpenAI API, the package's chat_api() function allows you to set API parameters such as the model you want to use, maximum tokens you're willing to spend per request, and your desired response temperature (which I'll explain in more detail later in the article).

The chat_api() function returns a list, with the text portion of the response in YourVariableName$choices[[1]]$message$content. Other useful info is stored in the list, as well, such as the number of tokens used.

The askgpt package was created by Johannes Gruber, a post-doc researcher at Vrije Universiteit Amsterdam. It can be installed from CRAN.

gptstudio

This package and its sibling, gpttools (discussed below), feature RStudio add-ins to work with ChatGPT, although there are also some command-line functions that will work in any IDE or terminal.

You can access add-ins within RStudio either from the add-in drop-down menu above the code source pane or by searching for them via the RStudio command palette (Ctrl-shift-p).

According to the package website, gptstudio is a general-purpose helper "for R programmers to easily incorporate use of large language models (LLMs) into their project workflows." It is on CRAN.

One add-in, ChatGPT, launches a browser-based app for asking your R coding questions, and offers options for programming style (tidyverse, base, or no preference) and proficiency (beginner, intermediate, advanced, and genius).

In the screenshot below, I've asked how to create a scatter plot in R as an intermediate coder with a tidyverse style. 

Screen shot by Sharon Machlis

Asking the same question with the base programming style produced code using base R’s plot function as the answer.

Although designed for R coding help, gptstudio can tap into more ChatGPT capabilities, so you can ask it anything that you would the original web-based ChatGPT. For instance, this app worked just as well as a ChatGPT tool to write Python code and answer general questions like, "What planet is farthest away from the sun?"

Another of the gptstudio package's add-ins, ChatGPT in Source, seems closest to magic. You write code as usual in your source pane, add a comment requesting changes you'd like in the code, select the block of code including your comment, and apply the add-in. Then, voilà! Your requested changes are made.

When I applied the add-in to this code:

# Sort bars by descending Y value, rotate x-axis text 90 degrees, color bars steel blue
ggplot(states, aes(x = State, y = Pop_2020)) +
  geom_col()

My code was replaced with what is shown in the highlighted selection of Figure 4:

Screen shot by Sharon Machlis

That's cool . . . except if you run this code, the bars won't display as steel blue. Moving fill = "steelblue" inside geom_col() makes it work. That mistake has nothing to do with this specific add-in, but with the vagaries of ChatGPT itself. As I previously mentioned, I've run the same request other times and the results were accurate.

Sending the following code to the ChatGPT in Source add-in generated complete instructions and code for a Shiny app:

# Create an R Shiny app with this data
states <- readr::read_csv("https://raw.githubusercontent.com/smach/SampleData/main/states.csv")

Submitting my request twice returned two completely different results, however—the first with a two-file app that forgot to load the ggplot2 library before using it the second calling columns that weren't actually in the data. It takes more work to craft a query that handles the specifics of an existing data set, but the code still could serve as a framework to build on.

gptstudio was written by Michel Nivard and James Wade.

gpttools

The aim of the gpttools package "is to extend gptstudio for R package developers to more easily incorporate use of large language models (LLMs) into their project workflows," according to the package website. The gpttools package isn't on CRAN as of this writing. Instead, you can install gpttools from the JamesHWade/gpttools GitHub repo or R Universe with the following:

# Enable repository from jameshwade
options(repos = c(
  jameshwade = "https://jameshwade.r-universe.dev",
  CRAN = "https://cloud.r-project.org"
))
# Download and install gpttools in R
install.packages("gpttools")

The package's add-ins include:

• ChatGPT with Retrieval
• Convert Script to Function
• Add roxygen to Function (documents a function)
• Suggest Unit Test
• Document Data
• Suggest Improvements

To run an add-in, highlight your code and then select the add-in either from the RStudio Addins dropdown menu or by searching for it in the command palette (Tools> Demonstrate Command Palette in the RStudio Addins menu or Ctrl-Change-P on Home windows, or Cmd-Shift-P on a Mac).

When I ran an insert-in, I didn't constantly see a information telling me that some thing was going on, so be affected individual.

The Counsel Enhancements incorporate-in created uncommented text underneath my purpose in an R file adopted by modified code. Some of the suggestions were not incredibly helpful. For example, for this code

  if (exportcsv) 
    filename_root <- strsplit(filename, "\.")[[1]][1]
    filename_with_winner <- paste0(filename_root, "_winners.csv")
    rio::export(data, filename_with_winner)
  
  

the add-in recommended

Use `paste()` instead of `paste0()` to ensure a space is included between the names of the winners.

I didn't want a space in my file name! Still, I couldn't argue with all of its advice. The following suggestion seemed reasonable:

Use a switch statement instead of multiple if statements, to allow for additional functionality in the future

In this case, I'd be more likely to use dplyr's case_when() or data.table's fcase() than base R's switch().

Make sure you have an original copy of your code if you're using any package's ChatGPT add-in, since there is a risk of code being overwritten in a way you don't necessarily want.

chatgpt

The chatgpt R package offers both functions and RStudio add-ins for using ChatGPT in R, with 10 add-ins documented at the time I tested.

Code-specific functions include comment_code(), complete_code(), create_unit_tests(), document_code(), find_issues_in_code(), and refactor_code(). There's also a generic ask_chatgpt() function and add-in if you'd like to use ChatGPT for something not code-related.

Store your key in your .Renviron file with

OPENAI_API_KEY="your key"

and you're good to go. If you attempt to run one of the add-ins before storing your key, you'll get an error message telling you how to do the key setup.