Originally developed as part of the OHDSI (Observational Health Data Sciences and Informatics) ecosystem, FeatureExtraction is particularly well-suited for working with large-scale observational data. In this post, we’ll explore the package in detail, focusing on its core features, practical applications, and a step-by-step example to help you get started.

Key Features and Capabilities

1. Automated Feature Generation

FeatureExtraction excels at automatically generating a wide range of features from raw data. These features include basic demographic variables like age and gender, as well as more complex attributes derived from longitudinal data, such as the frequency of medical visits or the presence of certain conditions over time.

2. Temporal Features

Temporal data, such as patient histories or time-dependent events, are common in many fields, especially healthcare. FeatureExtraction handles temporal data adeptly, allowing users to define time windows relative to key events (e.g., diagnosis dates). This feature is crucial for creating time-sensitive covariates that capture trends and patterns in data over specified periods.

3. Custom Feature Extraction

While the package offers extensive automated capabilities, it also allows for custom feature extraction. Users can define custom covariates and specify how these should be generated from the underlying data, incorporating domain-specific knowledge into the feature engineering process.

4. Scalability

Feature engineering can become computationally intensive, particularly with large datasets. FeatureExtraction is designed for scalability, leveraging parallel processing and optimized algorithms to ensure that feature extraction remains efficient even with big data.

5. Integration with OHDSI Tools

As part of the OHDSI ecosystem, FeatureExtraction integrates seamlessly with other tools like PatientLevelPrediction and CohortMethod, enabling a smooth workflow from data extraction to model building and analysis.

Getting started

Installing the FeatureExtraction package is straightforward. You can install it directly from CRAN using the following command:

# Explore the covariate data
summary(covariateData)

This simple example demonstrates how FeatureExtraction can be used to create meaningful features based on different cohorts. The package’s flexibility and scalability make it a powerful tool for a wide range of applications, from small-scale studies to large observational databases.

The post FeatureExtraction on CRAN appeared first on Ger Inberg.

The post DrugExposure Diagnostics appeared first on Ger Inberg.

Problem

Shiny apps are, by default, a bit limited when looking at it from this perspective.  It can handle only GET requests by default, unless you are a technical expert in this field, see this stack overflow post. Furthermore shiny apps can have just one entry-point “/”. So you can’t have another entry-point “/page2”. Thus, the e-commerce shop is not possible out of the box in R shiny.

Solution

There are multiple solutions to support multiple pages. The one that I am using since a while is the package brochure developed by Colin Fay. It is still in development, so you might encounter some issues but I haven’t found any major bugs yet. A brochure app consists of a series of pages that are defined by an endpoint/path, a UI and a server function. Thus each page has its own shiny session, its own UI, and its own server! This is important to keep in mind.  A separate session for each page has some advantages but also some disadvantages (e.g. how to pass user data between pages?). A very simple brochureApp looks like this:

library(shiny)
library(brochure)

brochureApp(
  # First page
  page(
    href = "/",
    ui = fluidPage(
      h1("My first page"), 
      plotOutput("plot")
    ),
    server = function(input, output, session){
      output$plot <- renderPlot({
        plot(iris)
      })
    }
  ), 
  # Second page, no server-side function
  page(
    href = "/page2", 
    ui =  fluidPage(
      h1("My second page")
    )
  )
)

Donation app

Coming back to the E-commerce shop example, I have developed an app where one can sponsor me for my open source work on R packages. The app has an integration with Stripe to make a donation and a thank you and error page. When calling Stripe you have to give the two endpoints for these pages and by using brochure, I am able to setup these endpoints. See the app on shinyapps.io and of course I would appreciate it, if you use the app!:-)

The post Multi page shiny apps appeared first on Ger Inberg.

See the live version. Let me know if you like it or you are interested in some other charts. Enjoy the Winter Olympics!

The post Speed skating viz updated appeared first on Ger Inberg.

In order to serve patients as best as they can, researchers need as much (quality) data that can serve their purpose.Surveillance, Tracking and Reporting through Informed Data Collection and Engagement (STRIDE) is an interactive data and visualization dashboard. It includes clinical trials enrollment, bio-specimen inventory, tumor registry analytic cases, and catchment area information.

They have approached me to improve the user interface of their dashboard and that’s what I have been doing! Next to this, I have been helping the person that created the initial dashboard with the following concepts.

• DRY (Don’t Repeat Yourself); this is basically re-using of code that you already wrote so you don’t have to write this code again and you will end up with less code to maintain.
• Reproducible results. When I tried to run the initial dashboard, it didn’t work since some packages were not imported and it was not clear which version of those packages I should use. I have added renv as dependency management, this will add a file to your project containing all packages and their versions. It’s easy to setup and it’s worth it!
• Interactive charts. The initial charts were made with the package ggplot2. This is a nice package for data visualization and it offers many charts and display options. But, it’s not interactive and that’s what most people want and expect in a dashboard.

See below for some screenshots of this app.

The post Catchment Area Research Dashboard appeared first on Ger Inberg.

Exploratory Analysis

Exploratory data analysis (EDA) is used by data scientists to analyze and investigate data sets and summarize their main characteristics. This is often done by using data visualization methods. The main purpose of EDA is to help look at data before making any assumptions. For me it’s one of the nicest parts of the data science! Since you don’t know yet what’s in the data and there will always be surprises. It’s like you are on holiday and exploring the area that you seeing for the first time:-)

For example, is a certain variable in the data normally distributed or not? Is there any missing data or duplicated values? In my experience, yes in most cases, there is missing and duplicated data. We need to fix these issues before we can do the real analysis. This phase is called data cleaning, you might have heard about this before.

Representativeness Analyses

In general, a representative sample is a group or set chosen from a larger statistical population that adequately replicates the larger group according to whatever characteristic or quality is under study. In case of CITO, we like to know if the sample data set has more or less the same characteristics regarding scores.  For example, are the average and standard deviation of the sample data set close to the ones of the total data set. I have plotted the distributions of the 2 data sets in a single chart, in order to compare them. In the subtitle one can find the average, standard deviation and the median.

Below you can find some of the charts I made for both EDA and the representativeness Analyses. The code is available in a public repository on github. It can be run using a docker container, R and renv for library management.

The post CITO public analysis appeared first on Ger Inberg.

redaction is the blacking out or deletion of text in a document. It is intended to allow the selective disclosure of information in a document while keeping other parts of the document secret. It is common within court documents and in the government. Categories of redacted items are phone numbers, e-mail addresses, bank account numbers, dates and names. It takes quite some time to manually redact documents, but fortunately AI can help to speed up this process. Natural Language Processing (NLP) is a subfield of AI that studies how to analyze and process a piece of natural text. This technology allows us to extract the keywords from the text.

Slimmer AI develops AI software products that support industries, solve real-world challenges and takes professionals into the future. They have developed an API that allows the redaction of PDF files. This API returns the redacted document based on your redaction action (e.g. all phone numbers). I have collaborated with Slimmer AI on building the interface for their new redaction application. 

Redaction Application

The developed application has the following features:

• search for keyword(s) in the text, this can be a regular expression
• AI search: search for items in a category like phone numbers
• select a piece of text in the document
• redact the results from the actions above
• display the redacted PDF

Below you see a screenshot of the application. The left sidebar is the search column where the keyword and AI search can be performed. At the bottom of this sidebar, the results of the search are shown. When a user clicks on a result, it is selected for redaction.

The center of the application contains the document. This is the section where the text selection is performed. Once a piece of text is selected a popup appears that asks if the selected text should be redacted or not.

The right column contains the items that have been selected for redaction. When the user pushes the ‘Redact All’ button, the document is processed on the backend and the middle section will show the redacted version of the document.

The application uses the PDF.JS library for basic functionality like rendering the PDF and selecting some text. It is a free and open source library. There are some commercial libraries that offer more functionality, but they were unrequired. The rest of the technology stack for the application includes Javascript, JQuery, Bootstrap4 and HTML/CSS.

Improvements

The application was meant as a Proof of Concept to see if we could create a user-friendly wrapper for the API. Since the current functionality is working well, the application is being further developed. One thing on the improvements list is the option for a rectangle select. So next to redacting a piece of text on a line, like we can do now, this allows the user to redact any rectangular area in the document. 

The post AI Redaction Application appeared first on Ger Inberg.

My energy provider is giving me my monthly usage and production. Based on this I have created the visual below. It states for each month the consumption (red) vs the production (blue). The electricity meter is installed at March 1 so there is no data before that date. The solar panels have been installed in May. So far this year the numbers are looking very good, since the solar panels produce the most in spring and summer. In the coming months the bars will be more red! See below for my current balance or have a look at my energy for the current status.

The post My Electricity Balance appeared first on Ger Inberg.

The post eRum lightning talk speaker appeared first on Ger Inberg.

You might have heard about linear regression and machine learning before. Basically linear regression is a simple statistics problem.  But what are the different types of linear regression and how to implement these in R?

Introduction to Linear Regression

Linear regression is an algorithm developed in the field of statistics. As the name suggests, linear regression assumes a linear relationship between the input variable(s) and a single output variable. The output variable, what you’re predicting, has to be continuous. The output variable can be calculated as a linear combination of the input variable(s).

There are two types of linear regression:

• Simple linear regression – only one input variable
• Multiple linear regression – multiple input variables

We will implement both today – simple linear regression from scratch and multiple linear regression with built-in R functions.

You can use a linear regression model to learn which features are important by examining coefficients. If a coefficient is close to zero, the corresponding feature is considered to be less important than if the coefficient was a large positive or negative value. 

That’s how the linear regression model generates the output. Coefficients are multiplied with corresponding input variables, and in the end, the bias (intercept) term is added.

There’s still one thing we should cover before diving into the code – assumptions of a linear regression model:

• Linear assumption — model assumes that the relationship between variables is linear
• No noise — model assumes that the input and output variables are not noisy — so remove outliers if possible
• No collinearity — model will overfit when you have highly correlated input variables
• Normal distribution — the model will make more reliable predictions if your input and output variables are normally distributed. If that’s not the case, try using some transforms on your variables to make them more normal-looking
• Rescaled inputs — use scalers or normalizer to make more reliable predictions

You should be aware of these assumptions every time you’re creating linear models. We’ll ignore most of them for the purpose of this article, as the goal is to show you the general syntax you can copy-paste between the projects. 

Simple Linear Regression from Scratch

If you have a single input variable, you’re dealing with simple linear regression. It won’t be the case most of the time, but it can’t hurt to know. A simple linear regression can be expressed as:As you can see, there are two terms you need to calculate beforehand: beta0 and beta1. You’ll first see how to calculate Beta1, as Beta0 depends on it. This is the formula:And this is the formula for Beta0:

These x’s and y’s with the bar over them represent the mean (average) of the corresponding variables.

Let’s see how all of this works in action. The code snippet below generates X with 500 linearly spaced numbers between 1 and 500, and generates Y as a value from the normal distribution centered just above the corresponding X value with a bit of noise added. Both X and Y are then combined into a single data frame and visualized as a scatter plot with the plotly package:

library(plotly)
# Generate synthetic data with a linear relationship
x <- seq(from = 1, to = 500)
y <- rnorm(n = 500, mean = 0.5*x + 70, sd = 30)
lr_data <- data.frame(x, y)

# create the plot
plot_ly(data = lr_data, x = ~x, y = ~y,
marker = list(size = 10)) %>%
layout(title = list(text = paste0('Simple linear regression', '<br><sup>', 'Linear relation is visible', '</sup>'))) %>%
config(displayModeBar = F)

The predictions can then be obtained by applying the lr_predict() function to the vector X – they should all be on a single straight line. Finally, input data and predictions are visualized:

# Calculate coefficients
b1 <- (sum((x - mean(x)) * (y - mean(y)))) / (sum((x - mean(x))^2))
b0 <- mean(y) - b1 * mean(x)

# Define function for generating predictions
lr_predict <- function(x) { return(b0 + b1 * x) }

# Calculated predictions: Apply lr_predict() to input
lr_data$ypred <- sapply(x, lr_predict)

# Visualize input data and the best fit line
plot_ly(data = lr_data, x = ~x) %>%
add_markers(y = ~y, marker = list(size = 10)) %>%
add_lines(x = ~x, y = lr_data$ypred, line = list(color = "black", width = 5)) %>%
layout(title = list(text = paste0('Applying simple linear regression to data', '<br><sup>', 'Black line = best fit line', '</sup>')),
showlegend = FALSE) %>%
config(displayModeBar = F)

And that’s how you can implement simple linear regression in R! 

Multiple Linear Regression

You’ll use the Boston Housing dataset to build your model. To start, the goal is to load in the dataset and check if some of the assumptions hold. Normal distribution and outlier assumptions can be checked with boxplots.

The code snippet below loads in the dataset and visualizes box plots for every feature (not the target):

library(reshape)

df <- read.csv("https://raw.githubusercontent.com/
                ginberg/boston_housing/master/housing.csv")

# Remove target variable
temp_df <- subset(df, select = -c(MEDV))
melt_df <- melt(temp_df)

plot_ly(melt_df, 
        y = ~value, 
        color = ~variable, 
        type = "box") %>%
   config(displayModeBar = F)

A degree of skew seems to be present in all input variables, and they all contain a couple of outliers. We’ll keep this blog to machine learning based, so we won’t do any data preparation/cleaning.

The next step once you’re done with preparation is to split the data into testing and training data. The caTools package is the perfect candidate for this task. 

You can train the model on the training set after the split. R has the lm function built-in, and it is used to train linear models. Inside the lm function, you’ll need to write the target variable on the left and input features on the right, separated by the  ~ sign. If you put a dot instead of feature names, it means you want to train the model on all features.

After the model is trained, you can call the summary() function to see how well it performed on the training set. Here’s a code snippet for everything discussed above:

library(caTools)
set.seed(21)

# Train/Test split, 80:20 ratio
sample_split <- sample.split(Y = df$MEDV, SplitRatio = 0.8)
train_set    <- subset(x = df, sample_split == TRUE)
test_set     <- subset(x = df, sample_split == FALSE)
# Fit the model and print summary
model        <- lm(MEDV ~ ., data = train_set)
summary(model)

The most interesting result are the P-values, displayed in the Pr(>|t|) column. Those values indicate the probability of a variable not being important for prediction. It’s common to use a 5% significance threshold, so if a P-value is 0.05 or below, we can say that there’s a low chance it is not significant for the analysis.

Let’s make a residuals plot now. As a general rule, if a histogram of residuals looks normally distributed, the linear model is as good as it can be. If not, it means you can improve it. Here’s the code for visualizing residuals:

# Get residuals
lm_residuals <- as.data.frame(residuals(model))

# Visualize residuals
plot_ly(x = lm_residuals

As you can see, there’s a bit of skew present due to a large error on the far right. Now, let’s make predictions on the test set. You can use the predict() function to apply the model to the test set. You can combine the actual values and predictions into a single data frame, just so the evaluation becomes easier. Here’s how:

# predict price for test_set 
predicted_prices <- predict(model, newdata = test_set) 
result <- data.frame(Y = test_set$MEDV, Ypred = predicted_prices)

A good way of evaluating your regression models is to look at the RMSE (Root Mean Squared Error). This metric will inform you how wrong your model is on average. In this case, it reports back the average number of price units the model is wrong:

mse  <- mean((result$Y - result$Ypred)^2)
rmse <- sqrt(mse)

In this blog you’ve learned how to train linear regression models in R. You’ve implemented a simple linear regression model entirely from scratch. After that you have implemented a multiple linear regression model with  on the real dataset. You’ve also learned how to evaluate the model through summary functions, residuals plots, and the RMSE metric. 

If you want to implement machine learning in your organization, feel free to contact me.

The post Linear Regression with R appeared first on Ger Inberg.