Step 7: Deploy your model




Introduction

Once you have developed your model and deemed it good enough to be useful, you will want to deploy it. There is no single deployment method that is best for all models. Therefore, Domino offers four different deployment options. One may fit your needs better than the others depending on your use case.

The available deployment methods are:

  • Scheduled reports
  • Launchers
  • Web applications
  • Model APIs

The remaining sections of this tutorial are not dependent on each other. For example, you will not need to complete the Scheduled report section to understand and complete the Web application section.




Compute Environments

In our previous section, Step 5, we installed the Prophet package in Rstudio in order to train the model. In Domino any package installed in one worksession will not persist to another. In order to avoid having to re-install Prophet each time we need it, you can add it to a custom compute environment.

  1. Create a new compute environment.

    1.1. Go to the Environments page in Domino.

    show_environments_nav

    1.2. Click Create Environment.

    create_env_button

    1.3. Name the environment and enter a description for the new environment.

    name_env

    1.4. Click Create Environment.

    1.5. Click Edit Definition in the top right corner of the page.

    edit_env_button

    1.6. In the Dockerfile Instructions section, enter the following:

    RUN R --no-save -e "install.packages(c('prophet'))"
    

    edit_dockerfile_r

    1.7. Scroll to the bottom of the page and click Build

    This will start the creation of your new compute environment. These added packages will now be permanently installed into your environment and be ready whenever you start a job or workspace session with this environment selected.

    1.8. Go back to your project page and navigate to the Settings page.

    1.9. Select your newly created environment from the Compute Environments dropdown menu.

    select_custom_env

If you want to learn more about how to customize your environment, check out find out more in the Environments tutorials. You can also learn more about what’s included in our default environments, the Domino Analytics Distrubition.



Scheduled reports

The Scheduled Jobs feature in Domino allows you to run a script on a regular basis. In Domino, using the R package knitr, you can blend text, code, and plots in an RMarkdown to create attractive HTML or pdf reports automatically.

In our case, we can imagine that each day we receive new data on power usage and want to email out a visualization of the latest data daily.

  1. Start a new Rstudio session.

  2. Create a new Rmarkdown file named power_reprt.Rmd and select HTML as our desired output.

    new rmarkdown

  3. Rstudio automatically creates a sample Rmarkdown file for you, but you can replace it entirely with the following which reuses code from our power.R script from step 5.

    ---
    title: "Power_Report"
    output: html_document
    ---
    
    {r setup, include=FALSE}
    knitr::opts_chunk$set(echo = TRUE)
    library(tidyverse)
    library(lubridate)
    
    col_names <-  c('HDF', 'date', 'half_hour_increment',
                                                            'CCGT', 'OIL', 'COAL', 'NUCLEAR',
                                                                    'WIND', 'PS', 'NPSHYD', 'OCGT',
                                                                    'OTHER', 'INTFR', 'INTIRL', 'INTNED',
                                                                    'INTEW', 'BIOMASS', 'INTEM')
    df <- read.csv('data.csv',header = FALSE,col.names = col_names,stringsAsFactors = FALSE)
    
    #remove the first and last row
    df <- df[-1,]
    df <- df[-nrow(df),]
    
    #Tidy the data
    df_tidy <- df %>% gather('CCGT', 'OIL', 'COAL', 'NUCLEAR',
                                                                                                     'WIND', 'PS', 'NPSHYD', 'OCGT',
                                                                                                     'OTHER', 'INTFR', 'INTIRL', 'INTNED',
                                                                                                     'INTEW', 'BIOMASS', 'INTEM',key="fuel", value="megawatt")
    

R Markdown

Combining R Markdown, Knitr and Domino allows you to create attractive scheduled reports that mix text, code and plots.

      {r, warning=FALSE}
df_tidy <- df_tidy %>% mutate(datetime=as.POSIXct(as.Date(date, "%Y%m%d"))+minutes(30*(half_hour_increment-1)))
print(head(df_tidy))

Including Plots

You can also embed plots, for example:
      {r, echo=FALSE}
p <- ggplot(data=df_tidy, aes(x=datetime, y=megawatt, group=fuel)) +
  geom_line(aes(color=fuel))
print(p)
  1. With your new Rmarkdown file, you can “knit” this into an html file and preview it directly in Domino by hitting the “knit” button.

    knit button

  2. To create a repeatable report, you need to create a script that you can schedule that will automatically render your Rmarkdown file to html. Start by creating a new R script named render.r with the following code:

    rmarkdown::render("power_report.Rmd")
    
  3. Save your files and Stop and Commit your workspace.

  4. Go to the Scheduled Jobs page.

    schedule_notebook_1_r

  5. Enter the file that you want to run. This will be the name of your Jupyter notebook.

  1. Select how often and when to run the file.

  2. Enter emails of people to send the resulting file(s) to.

    emails_schedule

  3. Click Schedule.

To discover more tips on how to customize the resulting email, see Custom Notifications for more information.




Launchers

Launchers are simple web forms that allow users to run templatized scripts. They are especially useful if your script has command line arguments that dynamically change the way the script executes. For heavily customized script, those command line arguments can quickly get complicated. Launcher allow you to expose all of that as a simple web form.

Typically, we parameterize script files (i.e. files that end in .py, .R, or .sh). Since we have been working with Jupyter notebooks until now, we will parameterize a our R script that re-used what created in Step 5.

To do so, we will insert a few new lines of code into a copy of the R script, create a wrapper file to execute, and configure a Launcher.

  1. Parameterize your R script by setting it to take command line arguments:

    1.1. Start a Rstudio session.

    1.2. Create script named Power_for_Launcher.R with the following:

    library(tidyverse)
    library(lubridate)
    
    #Pass in commandline arguements
    args <- commandArgs(trailingOnly = TRUE)
    fuel_type <- as.integer(args[1])
    
    col_names <-  c('HDF', 'date', 'half_hour_increment',
                    'CCGT', 'OIL', 'COAL', 'NUCLEAR',
                    'WIND', 'PS', 'NPSHYD', 'OCGT',
                    'OTHER', 'INTFR', 'INTIRL', 'INTNED',
                    'INTEW', 'BIOMASS', 'INTEM')
    df <- read.csv('data.csv',header = FALSE,col.names = col_names,stringsAsFactors = FALSE)
    
    #remove the first and last row
    df <- df[-1,]
    df <- df[-nrow(df),]
    
    #Tidy the data
    df_tidy <- df %>% gather('CCGT', 'OIL', 'COAL', 'NUCLEAR',
                             'WIND', 'PS', 'NPSHYD', 'OCGT',
                             'OTHER', 'INTFR', 'INTIRL', 'INTNED',
                             'INTEW', 'BIOMASS', 'INTEM',key="fuel", value="megawatt" )
    
    #Create a new column datetime that represents the starting datetime of the measured increment.
    df_tidy <- df_tidy %>% mutate(datetime=as.POSIXct(as.Date(date, "%Y%m%d"))+minutes(30*(half_hour_increment-1)))
    
    #Filter the data
    df_fuel_type <- df_tidy %>% filter(fuel==fuel_type) %>% select(datetime,megawatt)
    
    #Save out data as csv
    write.csv(df_fuel_type, paste(fuel_type,"_",Sys.Date(),".csv",sep=""))
    
                     #Create a new column datetime that represents the starting datetime of the measured increment.
                     df_tidy <- df_tidy %>% mutate(datetime=as.POSIXct(as.Date(date, "%Y%m%d"))+minutes(30*(half_hour_increment-1)))
    
                     #Filter the data
                     df_fuel_type <- df_tidy %>% filter(fuel==fuel_type) %>% select(datetime,megawatt)
    
                     #Save out data as csv
                     write.csv(df_fuel_type, paste(fuel_type,"_",Sys.Date(),".csv",sep=""))
    

    1.3. Notice the lines in our script that defines an object from a command line arguements

    args <- commandArgs(trailingOnly = TRUE)
          fuel_type <- as.integer(args[1])
    

    1.4. Save the files and Stop and Commit the workspace session.

  1. Configure the Launcher.

    3.1. Go to the Launcher page. It is under the Publish menu on the project page.

    empty_launcher_page

    3.2. Click New Launcher.

    3.3. Name the launcher “Power Generation Forecast Data”

    3.4. Copy and paste the following into the field “Command to run”:

    Power_for_Launcher.sh ${fuel}
    

    You should see the parameters show up below:

    create_new_launcher_r

    3.5. Select the fuel_type parameter and change the type to Select (Drop-down menu)

    3.5.1. Copy and paste the following into the “Allowed Values” field:

    CCGT, OIL, COAL, NUCLEAR, WIND, PS, NPSHYD, OCGT, OTHER, INTFR, INTIRL, INTNED, INTEW, BIOMASS, INTEM
    

    3.7. Click Save Launcher

  2. Try out the Launcher.

    4.1. Go back to the main Launcher page.

    4.2. Click Run for the “Power Generation Forecast Trainer” launcher.

    4.3. Select a start date for the training data.

    4.4. Select a fuel type from the dropdown.

    4.5. Click Run

    run_launcher_r

This will execute the parameterized R scropt with the parameters that you selected. In this particular launcher, your dataset filtered based on your inpute parameter with the results returned as a csv. When the run has been completed, an email will be sent to you and others that you optionally specified in the launcher with the resulting files. If you would like to customize the email, see Custom Notifications for more information.




Model APIs

If you want your model to serve another application, you will want to serve it in the form of an API endpoint. Domino Model APIs are scalable REST APIs that can create an endpoint from any function in a Python or R script. The Domino Model APIs are commonly used when you need an API to query your model in near real-time.

For example, we created a model to forecast power generation of combined cycle gas turbines in the UK.

In this section, we will deploy an API that uses the model that we trained in Step 5 to predict the generated power given a date in the future. To do so, we will create a new compute environment to install necessary packages, create a new file with the function we want to expose as an API, and finally deploy the API.

  1. Create a new file with the function we want to expose as an API

    2.1. From the Files page of your project, click Add File.

    files_page_add

    2.2. Name your file forecast_predictor.R.

    2.3. Enter the following contents:

                     library("prophet")
                     m<-readRDS(file = "model.rds")
    
                     model_api<-function(year, month, day, hour, minute){
                     date <- paste(year,"-", month,"-", day," ",hour,":",minute, sep="")
                     date= as.POSIXct(date, "%Y-%m-%d %H:%M")
                     df_api <- data.frame(ds=date)
                     df2<- predict(m,df_api)
                     return(df2["yhat"])
    }
    

    2.4. Click Save.

    add_file_for_api_r

  1. Deploy the API.

    3.1. Go to the Publish/Model APIs page in your project.

    3.2. Click New Model.

    model_api_empty_state

    3.3. Name your model, provide a description, and click Next.

    new_model_setup_r

    3.4. Enter the name of the file that you created in the previous step.

    3.5. Enter the name of the function that you want to expose as an API.

    3.6. Click Create Model.

    new_model_setup_2_r

  2. Test the API.

    4.1 Wait for the Model API status to turn to Running. This may take a few minutes.

    4.2. Click the Overview tab.

    4.3. Enter the following into the tester:

    {
      "data": {
        "year": 2019,
        "month": 10,
        "day": 15,
        "hour": 8,
        "minute": 15
      }
    }
    

    4.4. Click Send. If successful, you will see the response on the right panel.

    test_model_r

As a REST API, any other common programming language will be able to call it. Code snippets from some popular languages are listed in the other tabs.




Web applications

When experiments in Domino yield interesting results that you want to share with your colleagues, you can easily do so with a Domino App. Domino supports hosting Apps built with many popular frameworks, including Flask, Shiny, and Dash.

While Apps can be significantly more sophisticated and provide far more functionality than a Launcher, they also require significantly more code and knowledge in at least one framework. In this section, we will take convert some of the code that we developed in Step 5 and create a ‘Shiny <https://shiny.rstudio.com/>’’ app.

  1. Add the app.R file, which will describe the app in Dash, to the project:

    library(tidyverse)
    library(lubridate)
    library(prophet)
    library(dygraphs)
    
    col_names <-  c('HDF', 'date', 'half_hour_increment',
                    'CCGT', 'OIL', 'COAL', 'NUCLEAR',
                    'WIND', 'PS', 'NPSHYD', 'OCGT',
                    'OTHER', 'INTFR', 'INTIRL', 'INTNED',
                    'INTEW', 'BIOMASS', 'INTEM')
    df <- read.csv('data.csv',header = FALSE,col.names = col_names,stringsAsFactors = FALSE)
    
    #remove the first and last row
    df <- df[-1,]
    df <- df[-nrow(df),]
    
    fuels <- c('CCGT', 'OIL', 'COAL', 'NUCLEAR',
               'WIND', 'PS', 'NPSHYD', 'OCGT',
               'OTHER', 'INTFR', 'INTIRL', 'INTNED',
              'INTEW', 'BIOMASS', 'INTEM')
    
    predict_ln <- round((nrow(df))*.2)
    
    #Tidy the data and split by fuel
    df_tidy <- df %>%
      mutate(ds=as.POSIXct(as.Date(date, "%Y%m%d"))+minutes(30*(half_hour_increment-1))) %>%
      select(-c('HDF', 'date', 'half_hour_increment')) %>%
      gather("fuel", "y", -ds) %>%
      split(.$fuel)
    
    #remove unused column
    df_tidy <- lapply(df_tidy, function(x) { x["fuel"] <- NULL; x })
    
    #Train the model
    m_list <- map(df_tidy, prophet)
    
    #Create dataframes of future dates
    future_list <- map(m_list, make_future_dataframe, periods = predict_ln,freq = 1800 )
    
    #Pre-Calc yhat for future dates
    #forecast_list <- map2(m_list, future_list, predict) # map2 because we have two inputs
    
    
    
    ui <- fluidPage(
        verticalLayout(
          h2(textOutput("text1")),
         selectInput(inputId = "fuel_type",
                     label = "Fuel Type",
                     choices = fuels,
                     selected = "CCGT"),
          dygraphOutput("plot1")))
    
    server <- function(input, output) {
    output$plot1 <- renderDygraph({
      forecast <- predict(m_list[[input$fuel_type]],future_list[[input$fuel_type]] )
        dyplot.prophet(m_list[[input$fuel_type]], forecast)
         })
    output$text1 <- renderText({ input$fuel_type })
    }
    
    shinyApp(ui = ui, server = server)
    
  2. Add an app.sh file to the project, which provides the commands to instantiate the app:

    R -e 'shiny::runApp("app.R", port=8888, host="0.0.0.0")'
    
  3. Publish the App.

    3.1. Navigate to the App page under the Publish menu of your project.

    3.2. Enter a title and a description for you app.

    app_publish

    3.3. Click Publish.

    3.4. Once your app starts successfully, which may take a few minutes, you can click View App to open it.

    open_and_use_app

  4. Share your app with your colleagues.

    4.1 Back on the Publish/App page, select the App Permissions tab.

    4.2. Invite your colleagues by username or email.

    4.3. Or, toggle the Access Permissions level to make it publicly available.

    share_app

Learn more about Domino Apps.