How to Normalize Data Between 0 and 1 in R

Core Methods for Normalization in R

To effectively scale values in R, data practitioners typically utilize one of two primary approaches: defining a custom function using Base R operations or leveraging specialized functions provided by community packages, such as the widely used scales package.

Method 1: Custom Function using Base R

The Base R approach requires the user to define a straightforward custom function that explicitly implements the Min-Max scaling mathematical formula. This method is highly transparent, relying solely on core R functions like min() and max(). It is often preferred in environments where minimizing external dependencies is a priority.

#define function to scale values between 0 and 1
scale_values <- function(x){(x-min(x))/(max(x)-min(x))}

x_scaled <- rescale(x)

The function scale_values takes a numeric vector x, calculates the numerator (x minus the minimum value) and divides it by the denominator (the range of the data, calculated as the maximum value minus the minimum value).

Method 2: Leveraging the scales Package

A more concise and arguably cleaner approach involves utilizing the dedicated rescale() function available in the scales package. This package is maintained by the R community and offers a simplified syntax for normalization, abstracting the explicit mathematical calculation away from the user.

library(scales)

x_scaled <- rescale(x)

While this method requires loading an external package, its conciseness and built-in flexibility (such as the ability to easily specify custom target ranges) make it a popular choice for routine data preparation in R projects.

Setting Up the Example Data Frame

To properly illustrate the application of both scaling methods, we will define a sample data frame in R. This data structure, named df, tracks sales figures for eight different retail stores, allowing us to focus on scaling the numeric sales column.

#create data frame
df <- data.frame(store=c('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'),
                 sales=c(12, 24, 23, 59, 45, 34, 50, 77))

#view data frame
df

  store sales
1     A    12
2     B    24
3     C    23
4     D    59
5     E    45
6     F    34
7     G    50
8     H    77

As shown in the output, the raw data exhibits sales values ranging from a minimum of 12 up to a maximum of 77. The goal of the following examples is to transform these figures so that they occupy the 0 to 1 interval, with 12 mapping precisely to 0 and 77 mapping precisely to 1.

Example 1: Scaling Values Between 0 and 1 Using Base R

This first example applies the custom-defined function to the sales column of our data frame. We rely entirely on Base R syntax to achieve the required normalization, demonstrating how to incorporate custom logic directly into data processing workflows.

We first ensure the scaling function is defined in the environment, and then use standard subsetting syntax (df$sales) to apply the function exclusively to the target column, overwriting the original values with their scaled counterparts.

#define function to scale values between 0 and 1
scale_values <- function(x){(x-min(x))/(max(x)-min(x))}

#scale values in 'sales' column to be between 0 and 1
df$sales <- scale_values(df$sales)

#view updated data frame
df

  store     sales
1     A 0.0000000
2     B 0.1846154
3     C 0.1692308
4     D 0.7230769
5     E 0.5076923
6     F 0.3384615
7     G 0.5846154
8     H 1.0000000

As clearly demonstrated by the output, the values in the sales column are now successfully standardized between 0 and 1. The proportionality is maintained, meaning stores with high sales (like H) retain the highest relative position (1.000) and stores with low sales (like A) retain the lowest position (0.000).

Verification of Min-Max Scaling Logic

The custom function implemented above relies on the precise mathematical formula for scaling values. The formula is stated as follows:

• Scaled value = (Value – Min Value) / (Max Value – Min Value)

Considering our dataset where Min = 12 and Max = 77, the range (Max – Min) is 65. We can manually verify the scaled output for key observations to confirm the function’s accuracy.

For instance, calculating the scaled value for Store A (Sales = 12) confirms that the minimum value correctly maps to zero:

• Scaled value = (12 – 12) / (77 – 12) = 0 / 65 = 0.0000.

Similarly, calculating the scaled value for Store B (Sales = 24) verifies the proportional transformation:

• Scaled value = ( 24 – 12) / (77 – 12) = 12 / 65 = 0.1846.

Example 2: Scaling Values Using the scales Package

For comparison, we now demonstrate the streamlined approach using the rescale() function from the scales package. This approach is much more succinct, requiring only the function call after the package has been loaded into the R session.

Assuming we either reset the data frame or are applying this to a new unscaled vector, the process involves loading the library and applying rescale() directly to the target column.

library(scales)

#scale values in 'sales' column to be between 0 and 1
df$sales <- rescale(df$sales)

#view updated data frame
df

  store     sales
1     A 0.0000000
2     B 0.1846154
3     C 0.1692308
4     D 0.7230769
5     E 0.5076923
6     F 0.3384615
7     G 0.5846154
8     H 1.0000000

The scaled values derived from the rescale() function are precisely identical to those calculated using the custom Base R function. This consistency reinforces the accuracy of both methods for standard 0–1 normalization.

Extending the Range Using the to Argument

A major advantage of using the rescale() function is its inherent ability to scale data to any arbitrary range beyond 0 and 1, managed via the to argument. This flexibility is essential when specific downstream analysis tools require inputs within a custom boundary, such as 0 to 100, or -1 to 1.

The following code demonstrates how easily we can adapt the normalization process to scale the values in the sales column to range between 0 and 100 instead, effectively converting the proportional relationship into a percentage scale. We simply pass to=c(0, 100) as an additional parameter to the function.

library(scales)

#scale values in 'sales' column to be between 0 and 100
df$sales <- rescale(df$sales, to=c(0,100))

#view updated data frame
df

  store     sales
1     A   0.00000
2     B  18.46154
3     C  16.92308
4     D  72.30769
5     E  50.76923
6     F  33.84615
7     G  58.46154
8     H 100.00000

The updated sales column now shows values scaled between 0 and 100, where the original minimum (12) maps to 0 and the original maximum (77) maps to 100. This highly adaptable feature solidifies rescale() as a superior tool for dynamic data transformation within R.