Predicting car price

AI models to predict car price using car features

analysis
R
Author

Aditya Ranade

Published

May 15, 2025

I found this dataset on UCI machine learning repository which gives the dataset regarding the car features along with price. The goal is to predict the car price indicated by the variable price based on other features of the car like horespower, displacement, weight, etc. of car. We will compare multiple Machine Learning models for the same.

library(reshape2)
library(ggplot2)
library(ggh4x)
library(ggcorrplot)
library(GGally) # for pairs plot using ggplot framework
library(dplyr)
library(glmnet)
library(knitr)

# Get cars data from github repo
path <- "https://raw.githubusercontent.com/adityaranade/portfolio/refs/heads/main/car_price/automobile.data"
data0 <- read.table(path, 
                    sep = ",", 
                    fill = TRUE, 
                    header = FALSE)

colnames(data0) <- c( "symbolling", "normalized_losses", "make", "fuel_type", 
                      "aspiration", "doors","body_style", "drive_wheels", 
                      "engine_location", "wheel_base","length", "width", 
                      "height", "curb_weight", "engine_type", "cylinders", 
                      "engine_size", "fuel_system", "bore", "stroke", 
                      "compression_ratio", "horsepower", "peak_rpm", 
                      "city_mpg", "highway_mpg", "price")

# Check the type of data
data0 |> str()
'data.frame':   205 obs. of  26 variables:
 $ symbolling       : int  3 3 1 2 2 2 1 1 1 0 ...
 $ normalized_losses: chr  "?" "?" "?" "164" ...
 $ make             : chr  "alfa-romero" "alfa-romero" "alfa-romero" "audi" ...
 $ fuel_type        : chr  "gas" "gas" "gas" "gas" ...
 $ aspiration       : chr  "std" "std" "std" "std" ...
 $ doors            : chr  "two" "two" "two" "four" ...
 $ body_style       : chr  "convertible" "convertible" "hatchback" "sedan" ...
 $ drive_wheels     : chr  "rwd" "rwd" "rwd" "fwd" ...
 $ engine_location  : chr  "front" "front" "front" "front" ...
 $ wheel_base       : num  88.6 88.6 94.5 99.8 99.4 ...
 $ length           : num  169 169 171 177 177 ...
 $ width            : num  64.1 64.1 65.5 66.2 66.4 66.3 71.4 71.4 71.4 67.9 ...
 $ height           : num  48.8 48.8 52.4 54.3 54.3 53.1 55.7 55.7 55.9 52 ...
 $ curb_weight      : int  2548 2548 2823 2337 2824 2507 2844 2954 3086 3053 ...
 $ engine_type      : chr  "dohc" "dohc" "ohcv" "ohc" ...
 $ cylinders        : chr  "four" "four" "six" "four" ...
 $ engine_size      : int  130 130 152 109 136 136 136 136 131 131 ...
 $ fuel_system      : chr  "mpfi" "mpfi" "mpfi" "mpfi" ...
 $ bore             : chr  "3.47" "3.47" "2.68" "3.19" ...
 $ stroke           : chr  "2.68" "2.68" "3.47" "3.40" ...
 $ compression_ratio: num  9 9 9 10 8 8.5 8.5 8.5 8.3 7 ...
 $ horsepower       : chr  "111" "111" "154" "102" ...
 $ peak_rpm         : chr  "5000" "5000" "5000" "5500" ...
 $ city_mpg         : int  21 21 19 24 18 19 19 19 17 16 ...
 $ highway_mpg      : int  27 27 26 30 22 25 25 25 20 22 ...
 $ price            : chr  "13495" "16500" "16500" "13950" ...
# Convert the specific data types to numeric
data0$bore <- as.numeric(data0$bore)
data0$stroke <- as.numeric(data0$stroke)
data0$horsepower <- as.numeric(data0$horsepower)
data0$peak_rpm <- as.numeric(data0$peak_rpm)
data0$price <- as.numeric(data0$price)

# Check the type of data again
data0 |> str()
'data.frame':   205 obs. of  26 variables:
 $ symbolling       : int  3 3 1 2 2 2 1 1 1 0 ...
 $ normalized_losses: chr  "?" "?" "?" "164" ...
 $ make             : chr  "alfa-romero" "alfa-romero" "alfa-romero" "audi" ...
 $ fuel_type        : chr  "gas" "gas" "gas" "gas" ...
 $ aspiration       : chr  "std" "std" "std" "std" ...
 $ doors            : chr  "two" "two" "two" "four" ...
 $ body_style       : chr  "convertible" "convertible" "hatchback" "sedan" ...
 $ drive_wheels     : chr  "rwd" "rwd" "rwd" "fwd" ...
 $ engine_location  : chr  "front" "front" "front" "front" ...
 $ wheel_base       : num  88.6 88.6 94.5 99.8 99.4 ...
 $ length           : num  169 169 171 177 177 ...
 $ width            : num  64.1 64.1 65.5 66.2 66.4 66.3 71.4 71.4 71.4 67.9 ...
 $ height           : num  48.8 48.8 52.4 54.3 54.3 53.1 55.7 55.7 55.9 52 ...
 $ curb_weight      : int  2548 2548 2823 2337 2824 2507 2844 2954 3086 3053 ...
 $ engine_type      : chr  "dohc" "dohc" "ohcv" "ohc" ...
 $ cylinders        : chr  "four" "four" "six" "four" ...
 $ engine_size      : int  130 130 152 109 136 136 136 136 131 131 ...
 $ fuel_system      : chr  "mpfi" "mpfi" "mpfi" "mpfi" ...
 $ bore             : num  3.47 3.47 2.68 3.19 3.19 3.19 3.19 3.19 3.13 3.13 ...
 $ stroke           : num  2.68 2.68 3.47 3.4 3.4 3.4 3.4 3.4 3.4 3.4 ...
 $ compression_ratio: num  9 9 9 10 8 8.5 8.5 8.5 8.3 7 ...
 $ horsepower       : num  111 111 154 102 115 110 110 110 140 160 ...
 $ peak_rpm         : num  5000 5000 5000 5500 5500 5500 5500 5500 5500 5500 ...
 $ city_mpg         : int  21 21 19 24 18 19 19 19 17 16 ...
 $ highway_mpg      : int  27 27 26 30 22 25 25 25 20 22 ...
 $ price            : num  13495 16500 16500 13950 17450 ...
# Check the rows which do not have any entries
sum(is.na(data0)) # 16 NA values
[1] 16
# Exclude the rows with missing information
data1 <- na.omit(data0)

# Check NA values again
sum(is.na(data1)) # No NA values
[1] 0
# Check the first 6 rows of the dataset
data1 |> head()
  symbolling normalized_losses        make fuel_type aspiration doors
1          3                 ? alfa-romero       gas        std   two
2          3                 ? alfa-romero       gas        std   two
3          1                 ? alfa-romero       gas        std   two
4          2               164        audi       gas        std  four
5          2               164        audi       gas        std  four
6          2                 ?        audi       gas        std   two
   body_style drive_wheels engine_location wheel_base length width height
1 convertible          rwd           front       88.6  168.8  64.1   48.8
2 convertible          rwd           front       88.6  168.8  64.1   48.8
3   hatchback          rwd           front       94.5  171.2  65.5   52.4
4       sedan          fwd           front       99.8  176.6  66.2   54.3
5       sedan          4wd           front       99.4  176.6  66.4   54.3
6       sedan          fwd           front       99.8  177.3  66.3   53.1
  curb_weight engine_type cylinders engine_size fuel_system bore stroke
1        2548        dohc      four         130        mpfi 3.47   2.68
2        2548        dohc      four         130        mpfi 3.47   2.68
3        2823        ohcv       six         152        mpfi 2.68   3.47
4        2337         ohc      four         109        mpfi 3.19   3.40
5        2824         ohc      five         136        mpfi 3.19   3.40
6        2507         ohc      five         136        mpfi 3.19   3.40
  compression_ratio horsepower peak_rpm city_mpg highway_mpg price
1               9.0        111     5000       21          27 13495
2               9.0        111     5000       21          27 16500
3               9.0        154     5000       19          26 16500
4              10.0        102     5500       24          30 13950
5               8.0        115     5500       18          22 17450
6               8.5        110     5500       19          25 15250
# Select the numerical columns and then draw a pairs plot
# Pairs plot between the explanatory variables to 
# check correlation between each pair of the variables
data1 |> select(where(is.numeric)) |> ggpairs()

The response variable, price is correlated with all the variables which is good. However, the explanatory variables are correlated within themselves which is not a good indication. This indicates there is some multicollinearity. This means two variables give similar information about the response variable. One way to mitigate the effect is to consider the principal components and then use the principal components for the models. Another way is to use some regularization to mitigate the effect of multicollinearity.

# Histogram of price variable
ggplot(data1,aes(x=price))+
  geom_histogram(aes(y = after_stat(density)),bins = 30)+
  labs(title = "Distribution of Prices", 
       x = "price", y = "Density")

# log scale
ggplot(data1, aes(x = price)) + 
  geom_histogram(aes(y = after_stat(density)),bins = 30) +
  labs(title = "Log-Scale Distribution of Prices", 
       x = "log(price)", y = "Density") +
  scale_x_log10()

# Histogram of price according to make
ggplot(data1, aes(x = price, y = make)) + 
  geom_boxplot(fill="skyblue", col="black") +
  labs(title = "Price Distribution by Make", 
       x = "Make", y = "Price") +
  theme(axis.text.x = element_text(angle = 90, hjust = 1))

# Select specific columns for the ML model

data2 <- subset(data1, select = c(wheel_base,length,width,curb_weight,
                                 engine_size, bore,
                                 stroke,compression_ratio,horsepower,
                                 peak_rpm,city_mpg,highway_mpg,price))

# data2 <- data1 |> select(wheel_base,length,width,curb_weight,
#                         #fuel_type,cylinders,
#                         engine_size,bore, stroke,
#                         compression_ratio,horsepower,
#                         peak_rpm,city_mpg,highway_mpg,price)

# split the data into training and testing data
seed <- 55
set.seed(seed)

ind <- sample(1:nrow(data2),
              floor(0.8*nrow(data2)),
              replace = FALSE)

# Training dataset
data_train <- data2[ind,]
# Testing dataset
data_test <- data2[-ind,]
# Fit a linear regression model
# Fit a multiple linear regression model
model_lm <- glm(price ~ ., data = data_train)

# Check the summary of the model
model_lm |> summary()

Call:
glm(formula = price ~ ., data = data_train)

Coefficients:
                    Estimate Std. Error t value Pr(>|t|)    
(Intercept)       -5.396e+04  1.799e+04  -2.999 0.003196 ** 
wheel_base         1.334e+02  1.095e+02   1.218 0.225256    
length            -9.810e+01  6.262e+01  -1.566 0.119455    
width              6.062e+02  3.089e+02   1.962 0.051671 .  
curb_weight        4.439e+00  1.994e+00   2.227 0.027536 *  
engine_size        1.002e+02  1.868e+01   5.364 3.21e-07 ***
bore              -4.447e+02  1.465e+03  -0.304 0.761889    
stroke            -2.912e+03  8.441e+02  -3.450 0.000736 ***
compression_ratio  2.119e+02  1.012e+02   2.092 0.038165 *  
horsepower         2.922e+01  2.230e+01   1.311 0.192081    
peak_rpm           1.916e+00  7.966e-01   2.405 0.017435 *  
city_mpg          -3.215e+02  2.202e+02  -1.460 0.146381    
highway_mpg        3.579e+02  2.007e+02   1.783 0.076701 .  
---
Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1

(Dispersion parameter for gaussian family taken to be 10295453)

    Null deviance: 9190090574  on 155  degrees of freedom
Residual deviance: 1472249800  on 143  degrees of freedom
AIC: 2976.1

Number of Fisher Scoring iterations: 2
# Predictions on test data
y_pred_lm <- predict(model_lm, data_test)

# data frame for plotting
df_pred_mlr <- data.frame(predicted = y_pred_lm, 
                    observed = data_test$price)
df_pred_mlr$model <- "mlr"

# evaluation metrics
rmse_lm <- (data_test$price-y_pred_lm)^2 |> mean() |> sqrt()
mae_lm <- (data_test$price-y_pred_lm) |> abs() |> mean()
library(glmnet)
# Ensure all factor variables in test have the same levels as training
for (col in names(data_train)) {
  if (is.factor(data_train[[col]])) {
    data_test[[col]] <- factor(data_test[[col]], levels = levels(data_train[[col]]))
  }
}

# Now build matrices
X  <- model.matrix(price ~ . - 1, data = data_train)
y  <- data_train$price
X.new <- model.matrix(price ~ . - 1, data = data_test)

model_l2_cv <- cv.glmnet(X,y,alpha = 0)

#find optimal lambda value that minimizes test MSE
best_lambda <- model_l2_cv$lambda.min

model_l2 <- glmnet(X,y,
                   alpha = 1,
                   lambda = best_lambda)
#coef(model_l2)

# for predictions
X.new <- model.matrix(price ~ . - 1,
                      data = data_test)

# Predictions on test data
y_pred_l2 <- predict(model_l2,
                     s = best_lambda,
                     newx= X.new)

# data frame for plotting
df_pred_l2 <- data.frame(predicted = as.vector(y_pred_l2),
                         observed = data_test$price)
df_pred_l2$model <- "ridge"

# evaluation metrics 
rmse_l2 <- (data_test$price-y_pred_l2)^2 |> mean() |> sqrt()
mae_l2 <- (data_test$price-y_pred_l2) |> abs() |> mean()
model_l1_cv <- cv.glmnet(as.matrix(data_train[,-ncol(data_train)]),
                         as.matrix(data_train[,ncol(data_train)]),
                         alpha = 0)

#find optimal lambda value that minimizes test MSE
best_lambda_l1 <- model_l1_cv$lambda.min
best_lambda_l1
[1] 1174.377
model_l1 <- glmnet(as.matrix(data_train[,-ncol(data_train)]),
                   as.matrix(data_train[,ncol(data_train)]),
                   alpha = 0,
                   lambda = best_lambda_l1)
#coef(model_l1)

# Predictions on test data
y_pred_l1 <- predict(model_l1,  s = best_lambda_l1,
                     newx= as.matrix(data_test[,-ncol(data_train)]))

# data frame for plotting
df_pred_l1 <- data.frame(predicted = as.vector(y_pred_l1),
                         observed = data_test$price)
df_pred_l1$model <- "ridge"

# evaluation metrics
rmse_l1 <- (data_test$price-y_pred_l1)^2 |> mean() |> sqrt()
mae_l1 <- (data_test$price-y_pred_l1) |> abs() |> mean()
# Elastic net
model_en_cv <- cv.glmnet(as.matrix(data_train[,-ncol(data_train)]),
                         as.matrix(data_train[,ncol(data_train)]),
                         alpha = 0.5)

#find optimal lambda value that minimizes test MSE
best_lambda_en <- model_en_cv$lambda.min


model_en <- glmnet(as.matrix(data_train[,-ncol(data_train)]),
                   as.matrix(data_train[,ncol(data_train)]),
                   alpha = 0.5,
                   lambda = best_lambda_en)
#coef(model_en)

# Predictions on test data
y_pred_en <- predict(model_en,  s = best_lambda_en,
                     newx= as.matrix(data_test[,-ncol(data_train)]))

# data frame for plotting
df_pred_en <- data.frame(predicted = as.vector(y_pred_en),
                    observed = data_test$price)
df_pred_en$model <- "elastic_net"

# evaluation metrics
rmse_en <- (data_test$price-y_pred_en)^2 |> mean() |> sqrt()
mae_en <- (data_test$price-y_pred_en) |> abs() |> mean()
# Tree approach
library(rpart)
library(rpart.plot)

# Fit regression tree
model_tree <- rpart(price ~ ., data = data_train, method = "anova")

# Summary
summary(model_tree)
Call:
rpart(formula = price ~ ., data = data_train, method = "anova")
  n= 156 

          CP nsplit  rel error    xerror       xstd
1 0.66748804      0 1.00000000 1.0108913 0.18358732
2 0.19874312      1 0.33251196 0.3413841 0.03673654
3 0.01975068      2 0.13376884 0.1499870 0.02214728
4 0.01882083      3 0.11401816 0.1438535 0.02136248
5 0.01000000      4 0.09519733 0.1338515 0.02033514

Variable importance
engine_size curb_weight    city_mpg  horsepower highway_mpg       width 
         22          20          15          13          13          12 
     length  wheel_base 
          4           1 

Node number 1: 156 observations,    complexity param=0.667488
  mean=12895.28, MSE=5.891084e+07 
  left son=2 (143 obs) right son=3 (13 obs)
  Primary splits:
      engine_size < 182    to the left,  improve=0.6674880, (0 missing)
      curb_weight < 2697.5 to the left,  improve=0.5362224, (0 missing)
      highway_mpg < 28.5   to the right, improve=0.5099084, (0 missing)
      city_mpg    < 22.5   to the right, improve=0.5085646, (0 missing)
      horsepower  < 118    to the left,  improve=0.5079888, (0 missing)
  Surrogate splits:
      curb_weight < 3338   to the left,  agree=0.981, adj=0.769, (0 split)
      width       < 69.25  to the left,  agree=0.968, adj=0.615, (0 split)
      city_mpg    < 16.5   to the right, agree=0.968, adj=0.615, (0 split)
      horsepower  < 169    to the left,  agree=0.962, adj=0.538, (0 split)
      highway_mpg < 21     to the right, agree=0.955, adj=0.462, (0 split)

Node number 2: 143 observations,    complexity param=0.1987431
  mean=11004.58, MSE=1.940408e+07 
  left son=4 (93 obs) right son=5 (50 obs)
  Primary splits:
      curb_weight < 2544   to the left,  improve=0.6582376, (0 missing)
      highway_mpg < 28.5   to the right, improve=0.5964810, (0 missing)
      wheel_base  < 98.95  to the left,  improve=0.5957530, (0 missing)
      length      < 176.4  to the left,  improve=0.5499178, (0 missing)
      width       < 66.05  to the left,  improve=0.5262094, (0 missing)
  Surrogate splits:
      highway_mpg < 28.5   to the right, agree=0.944, adj=0.84, (0 split)
      city_mpg    < 22     to the right, agree=0.909, adj=0.74, (0 split)
      engine_size < 126    to the left,  agree=0.902, adj=0.72, (0 split)
      horsepower  < 104    to the left,  agree=0.888, adj=0.68, (0 split)
      length      < 178.15 to the left,  agree=0.881, adj=0.66, (0 split)

Node number 3: 13 observations
  mean=33693, MSE=2.161777e+07 

Node number 4: 93 observations,    complexity param=0.01975068
  mean=8384.097, MSE=4263549 
  left son=8 (48 obs) right son=9 (45 obs)
  Primary splits:
      curb_weight < 2216.5 to the left,  improve=0.4577704, (0 missing)
      horsepower  < 83     to the left,  improve=0.3937776, (0 missing)
      engine_size < 105.5  to the left,  improve=0.3843303, (0 missing)
      length      < 175    to the left,  improve=0.3785992, (0 missing)
      wheel_base  < 98.6   to the left,  improve=0.3736707, (0 missing)
  Surrogate splits:
      length      < 167.4  to the left,  agree=0.882, adj=0.756, (0 split)
      width       < 64.5   to the left,  agree=0.882, adj=0.756, (0 split)
      engine_size < 105.5  to the left,  agree=0.882, adj=0.756, (0 split)
      wheel_base  < 96     to the left,  agree=0.871, adj=0.733, (0 split)
      city_mpg    < 27.5   to the right, agree=0.860, adj=0.711, (0 split)

Node number 5: 50 observations,    complexity param=0.01882083
  mean=15878.68, MSE=1.103613e+07 
  left son=10 (25 obs) right son=11 (25 obs)
  Primary splits:
      wheel_base  < 100.8  to the left,  improve=0.3134524, (0 missing)
      width       < 68.6   to the left,  improve=0.2351563, (0 missing)
      length      < 186.65 to the left,  improve=0.1914644, (0 missing)
      curb_weight < 2697.5 to the left,  improve=0.1466294, (0 missing)
      peak_rpm    < 5275   to the left,  improve=0.1203158, (0 missing)
  Surrogate splits:
      length            < 186.65 to the left,  agree=0.90, adj=0.80, (0 split)
      width             < 66.7   to the left,  agree=0.86, adj=0.72, (0 split)
      curb_weight       < 2930.5 to the left,  agree=0.80, adj=0.60, (0 split)
      bore              < 3.66   to the left,  agree=0.66, adj=0.32, (0 split)
      compression_ratio < 9.405  to the left,  agree=0.66, adj=0.32, (0 split)

Node number 8: 48 observations
  mean=7031.417, MSE=852175.8 

Node number 9: 45 observations
  mean=9826.956, MSE=3868779 

Node number 10: 25 observations
  mean=14018.76, MSE=6810907 

Node number 11: 25 observations
  mean=17738.6, MSE=8342755 
# control complexity of tree
printcp(model_tree) # shows cross-validated error by cp

Regression tree:
rpart(formula = price ~ ., data = data_train, method = "anova")

Variables actually used in tree construction:
[1] curb_weight engine_size wheel_base 

Root node error: 9190090574/156 = 58910837

n= 156 

        CP nsplit rel error  xerror     xstd
1 0.667488      0  1.000000 1.01089 0.183587
2 0.198743      1  0.332512 0.34138 0.036737
3 0.019751      2  0.133769 0.14999 0.022147
4 0.018821      3  0.114018 0.14385 0.021362
5 0.010000      4  0.095197 0.13385 0.020335
best_cp <- model_tree$cptable[which.min(model_tree$cptable[,"xerror"]), "CP"]

# Plot
model_tree_pruned <- prune(model_tree, cp = best_cp)
rpart.plot(model_tree_pruned, type = 3, extra = 101)

# Predictions on test data
y_pred_tree <- predict(model_tree, data_test)

# data frame for plotting
df_pred_tree <- data.frame(predicted = y_pred_tree, 
                    observed = data_test$price)
df_pred_tree$model <- "tree"

# evaluation metrics
rmse_tree <- (data_test$price-y_pred_tree)^2 |> mean() |> sqrt()
mae_tree <- (data_test$price-y_pred_tree) |> abs() |> mean()
# Random forest
library(randomForest)
model_rf <- randomForest(price ~ ., data = data_train)
predict(model_rf, data_test)
        3         6         9        13        21        22        25        42 
14262.940 14275.078 20853.727 18738.098  6010.565  5931.475  6588.243 11366.779 
       44        47        49        51        54        60        75        76 
 9030.611 11565.093 33850.958  6543.531  6804.512 10153.271 37203.109 19382.710 
       77        87        96       105       106       108       109       115 
 6039.265  8294.962  7361.326 16943.393 19797.553 16033.994 16451.646 17763.117 
      117       126       127       128       152       154       159       160 
16428.010 16002.628 30780.565 30780.565  6475.500  7676.276  8259.292  8255.036 
      162       174       193       194       195       198       200 
 8110.738 10512.567 12322.078 12314.946 15558.877 15669.915 18742.750 
# Predictions on test data
y_pred_rf <- predict(model_rf, data_test)

# data frame for plotting
df_pred_rf <- data.frame(predicted = y_pred_rf, 
                      observed = data_test$price)
df_pred_rf$model <- "random_forest"

# evaluation metrics
rmse_rf <- (data_test$price-y_pred_rf)^2 |> mean() |> sqrt()
mae_rf <- (data_test$price-y_pred_rf) |> abs() |> mean()
# SVM
library(e1071)
model_svm <- svm(price ~ ., data = data_train, 
                 kernel = "radial", cost = 10, 
                 gamma = 0.1)

# Predictions on test data
y_pred_svm <- predict(model_svm, data_test)

# data frame for plotting
df_pred_svm <- data.frame(predicted = y_pred_svm, 
                          observed = data_test$price)
df_pred_svm$model <- "svm"

# evaluation metrics
rmse_svm <- (data_test$price-y_pred_svm)^2 |> mean() |> sqrt()
mae_svm <- (data_test$price-y_pred_svm) |> abs() |> mean()
# Plot observed vs. predicted for all the models
df_pred <- rbind(df_pred_mlr, df_pred_tree, 
                 df_pred_l1,df_pred_l2,df_pred_en,
                 df_pred_rf, df_pred_svm)

# Create a observed vs. predicted plot combined for all the models
ggplot(df_pred,aes(predicted,observed))+geom_point()+
  lims(x = c(10000,50000) , y = c(10000,50000))+
  labs(y = "Observed", x="Predicted")+
  facet_grid(~model, scales="free")+
  geom_abline()+
  theme_bw(base_size = 15)

# Evaluation metrics for all the models
metrics_all <- data.frame(Model = c("linear_model", "lasso", "ridge",
                                    "elastic_net", "tree", "random_forest",
                                    "svm"),
                          RMSE = c(rmse_lm,rmse_l1, rmse_l2, rmse_en,
                                   rmse_tree, rmse_rf, rmse_svm),
                          MAE = c(mae_lm,mae_l1, mae_l2, mae_en,
                                  mae_tree, mae_rf, mae_svm))

# Print evaluation metrics
kable(metrics_all, digits = 0, caption = "Model Performance Metrics")
Model Performance Metrics
Model RMSE MAE
linear_model 3352 2475
lasso 3734 2543
ridge 4027 2693
elastic_net 3461 2477
tree 3502 2555
random_forest 2291 1552
svm 2313 1863 
metrics_long <- melt(metrics_all, id.vars = "Model",
                     variable.name = "Metric",
                     value.name = "Value")

# To plot RMSE and MAE side by side
ggplot(metrics_long, aes(x = Model, y = Value, fill = Model)) +
  geom_col(show.legend = FALSE) +
  geom_text(aes(label = round(Value)), 
            position = position_dodge(width = 0.5),
            hjust = 1.25, size = 3) +
  coord_flip(clip = "off") +  # horizontal bars, no clipping of text
  facet_grid2(~Metric, scales="free")+
  labs(title = "Model Performance Comparison", 
       y = "Error Value", x = "Model") +
  theme_bw(base_size = 15) +
  theme(plot.title = element_text(face = "bold", hjust = 0.5))

# # To plot RMSE and MAE on the same plot
# ggplot(metrics_long, aes(x = Model, y = Value, fill = Metric)) +
#   geom_col(position = position_dodge(width = 0.8)) +
#   geom_text(aes(label = round(Value, 2)),
#             position = position_dodge(width = 0.8),
#             vjust = -0.3, size = 3) +
#   labs(title = "Model Performance Comparison",
#        y = "Error Value", x = "Model") +
#   theme_bw(base_size = 10) +
#   theme(plot.title = element_text(face = "bold", hjust = 0.5))

Based on the metrics, random forest model seems to be the best model.