If you missed project 1 & 2 use the below links.

👉 Project-1

👉 Project-2

Hey there!

I am here to share with you another Machine Learning Project.

Don’t just read this article, I want you to get hands-on. So quickly open your laptop and download the below dataset👇.

Dataset: Car Price Prediction Dataset📁

After downloading the dataset, you will get a zip file.

Extract the zip file and get the “CarPrice_Assignment.csv” file. (You can change the name of the file if you want).

Now, open yourGoogle Colab and load the dataset you just extracted.

Done?

Then, let’s begin.

Loading the Dataset

As usual, let’s import pandas and load the csv file.

import pandas as pd
df = pd.read_csv('CarPricePrediction.csv')
df.head()

"""
OUTPUT:
 car_ID symboling CarName fueltype aspiration doornumber carbody drivewheel enginelocation wheelbase ... enginesize fuelsystem boreratio stroke compressionratio horsepower peakrpm citympg highwaympg price
0 1 3 alfa-romero giulia gas std two convertible rwd front 88.6 ... 130 mpfi 3.47 2.68 9.0 111 5000 21 27 13495.0
1 2 3 alfa-romero stelvio gas std two convertible rwd front 88.6 ... 130 mpfi 3.47 2.68 9.0 111 5000 21 27 16500.0
2 3 1 alfa-romero Quadrifoglio gas std two hatchback rwd front 94.5 ... 152 mpfi 2.68 3.47 9.0 154 5000 19 26 16500.0
3 4 2 audi 100 ls gas std four sedan fwd front 99.8 ... 109 mpfi 3.19 3.40 10.0 102 5500 24 30 13950.0
4 5 2 audi 100ls gas std four sedan 4wd front 99.4 ... 136 mpfi 3.19 3.40 8.0 115 5500 18 22 17450.0
5 rows × 26 columns
"""

(Pro Tip: If you want to see all the columns, then before df.head() use pd.set_option(‘display.max_columns’, 100))

Understanding the Dataset

df.shape # (205, 26)

df.isnull().sum()

"""
OUTPUT:
car_ID              0
symboling           0
CarName             0
fueltype            0
aspiration          0
doornumber          0
carbody             0
drivewheel          0
enginelocation      0
wheelbase           0
carlength           0
carwidth            0
carheight           0
curbweight          0
enginetype          0
cylindernumber      0
enginesize          0
fuelsystem          0
boreratio           0
stroke              0
compressionratio    0
horsepower          0
peakrpm             0
citympg             0
highwaympg          0
price               0
dtype: int64
"""

Our dataset is really small and we got 0 null values in it.

Let’s check the data types of the columns.

for i in df.columns:
  print(f"{i} : {df[i].dtype}")

"""
OUTPUT:
ar_ID : int64
symboling : int64
CarName : object
fueltype : object
aspiration : object
doornumber : object
carbody : object
drivewheel : object
enginelocation : object
wheelbase : float64
carlength : float64
carwidth : float64
carheight : float64
curbweight : int64
enginetype : object
cylindernumber : object
enginesize : int64
fuelsystem : object
boreratio : float64
stroke : float64
compressionratio : float64
horsepower : int64
peakrpm : int64
citympg : int64
highwaympg : int64
price : float64
"""

We have plenty of categorical columns in our dataset.

It would be nice to create two lists one containing all the categorical column names and the other containing all the numerical column names.

So, let’s do that.

cat_columns = []
num_columns = []
for i in df.columns:
  if df[i].dtype == object:
    cat_columns.append(i)
  else:
    num_columns.append(i)


cat_columns

"""
OUTPUT:
['CarName',
 'fueltype',
 'aspiration',
 'doornumber',
 'carbody',
 'drivewheel',
 'enginelocation',
 'enginetype',
 'cylindernumber',
 'fuelsystem']
"""

Nice!

Let’s see how many unique numbers of values each categorical column has using the nunique() method.

for i in cat_columns:
  print(f"{i}: {df[i].nunique()}")

"""
OUTPUT:
CarName: 147
fueltype: 2
aspiration: 2
doornumber: 2
carbody: 5
drivewheel: 3
enginelocation: 2
enginetype: 7
cylindernumber: 7
fuelsystem: 8
"""

The “carName” column has nearly 147 values. We need to do something about that, other than that all other columns are fine, we can handle them during the “Handling Categorical Variable” part.

Let’s also know the distribution of values in the categorical columns using value_counts() method.

print(df['fueltype'].value_counts())
print('------------------------------')
print(df['aspiration'].value_counts())
print('------------------------------')
print(df['doornumber'].value_counts())
print('------------------------------')
print(df['carbody'].value_counts())
print('------------------------------')
print(df['drivewheel'].value_counts())
print('------------------------------')
print(df['enginelocation'].value_counts())
print('------------------------------')
print(df['enginetype'].value_counts())
print('------------------------------')
print(df['cylindernumber'].value_counts())
print('------------------------------')
print(df['fuelsystem'].value_counts())

"""
OUTPUT:
std      168
turbo     37
Name: count, dtype: int64
------------------------------
doornumber
four    115
two      90
Name: count, dtype: int64
------------------------------
carbody
sedan          96
hatchback      70
wagon          25
hardtop         8
convertible     6
Name: count, dtype: int64
------------------------------
drivewheel
fwd    120
rwd     76
4wd      9
Name: count, dtype: int64
------------------------------
enginelocation
front    202
rear       3
Name: count, dtype: int64
------------------------------
enginetype
ohc      148
ohcf      15
ohcv      13
dohc      12
l         12
rotor      4
dohcv      1
Name: count, dtype: int64
------------------------------
cylindernumber
four      159
six        24
five       11
eight       5
two         4
three       1
twelve      1
Name: count, dtype: int64
------------------------------
fuelsystem
mpfi    94
2bbl    66
idi     20
1bbl    11
spdi     9
4bbl     3
mfi      1
spfi     1
Name: count, dtype: int64
"""

Good!

If you take a close look at the “CarName” column mostly the first 5 character seems to match. You will understand what I am trying to say if you see the below code and output.

df['CarName'] = df['CarName'].str[:5]

df['CarName'].head(40)

"""
OUTPUT:
0     alfa-
1     alfa-
2     alfa-
3     audi 
4     audi 
5     audi 
6     audi 
7     audi 
8     audi 
9     audi 
10    bmw 3
11    bmw 3
12    bmw x
13    bmw x
14    bmw z
15    bmw x
16    bmw x
17    bmw x
18    chevr
19    chevr
20    chevr
21    dodge
22    dodge
23    dodge
24    dodge
25    dodge
26    dodge
27    dodge
28    dodge
29    dodge
30    honda
31    honda
32    honda
33    honda
34    honda
35    honda
36    honda
37    honda
38    honda
39    honda
Name: CarName, dtype: object
"""

As you can see from the above output, if we reduce the string size to just 5 we are able to reduce the number of unique values present in the “CarName” column. See below.

df[cat_columns].nunique()

"""
OUTPUT:
CarName           31
fueltype           2
aspiration         2
doornumber         2
carbody            5
drivewheel         3
enginelocation     2
enginetype         7
cylindernumber     7
fuelsystem         8
"""

We reduced the unique value from 147 to 31.

As you already know we don’t have any null values in our dataset. So, we can skip the “Handling the Null Values” part and straight away move to the “Handling the Categorical Variables” part.

Handling the Categorical Variables

I am going to use replace() method to replace the values of few categorical columns with numbers.

Before that, I am going to create another data frame named df1, so that if I make any mistake my main data frame df will not be affected.

df1 = df.copy()

df1.replace({'fueltype':{'gas':0, 'diesel':1}}, inplace=True)
df1.replace({'aspiration':{'std':0, 'turbo':1}}, inplace=True)
df1.replace({'doornumber':{'four':0, 'two':1}}, inplace=True)
df1.replace({'enginelocation':{'front':0, 'rear':1}}, inplace=True)
df1.replace({'drivewheel':{'fwd':0, 'rwd':1, '4wd':2}}, inplace=True)
df1.replace({'carbody':{'sedan':0, 'hatchback':1, 'wagon':2, 'hardtop':3, 'convertible':4}}, inplace=True)
df1.replace({'cylindernumber':{'two':2, 'three':3, 'four':4, 'five':5, 'six':6, 'eight':8, 'twelve':12}}, inplace=True)

I haven’t used replace() method for few other columns because I am going to replace there value using a encoder called LabelEncoder.

Before that let’s see how our data frame looks now.

pd.set_option('display.max_columns', 100)
df1.head()

"""
OUTPUT:

car_ID symboling CarName fueltype aspiration doornumber carbody drivewheel enginelocation wheelbase carlength carwidth carheight curbweight enginetype cylindernumber enginesize fuelsystem boreratio stroke compressionratio horsepower peakrpm citympg highwaympg price
0 1 3 alfa- 0 0 1 4 1 0 88.6 168.8 64.1 48.8 2548 dohc 4 130 mpfi 3.47 2.68 9.0 111 5000 21 27 13495.0
1 2 3 alfa- 0 0 1 4 1 0 88.6 168.8 64.1 48.8 2548 dohc 4 130 mpfi 3.47 2.68 9.0 111 5000 21 27 16500.0
2 3 1 alfa- 0 0 1 1 1 0 94.5 171.2 65.5 52.4 2823 ohcv 6 152 mpfi 2.68 3.47 9.0 154 5000 19 26 16500.0
3 4 2 audi 0 0 0 0 0 0 99.8 176.6 66.2 54.3 2337 ohc 4 109 mpfi 3.19 3.40 10.0 102 5500 24 30 13950.0
4 5 2 audi 0 0 0 0 2 0 99.4 176.6 66.4 54.3 2824 ohc 5 136 mpfi 3.19 3.40 8.0 115 5500 18 22 17450.0
"""

We still got few categorical columns, let’s use the same formula we used earlier to store them in a list.

df1_cat_columns = []
df1_num_columns = []
for i in df1.columns:
  if df1[i].dtype == object:
    df1_cat_columns.append(i)
  else:
    df1_num_columns.append(i)


df1_cat_columns

"""
OUTPUT:
['CarName', 'enginetype', 'fuelsystem']
"""

df1[df1_cat_columns]

"""
OUTPUT:
 CarName enginetype fuelsystem
0 alfa- dohc mpfi
1 alfa- dohc mpfi
2 alfa- ohcv mpfi
3 audi ohc mpfi
4 audi ohc mpfi
... ... ... ...
200 volvo ohc mpfi
201 volvo ohc mpfi
202 volvo ohcv mpfi
203 volvo ohc idi
204 volvo ohc mpfi
205 rows × 3 columns
"""

It’s use LabelEncoder to convert the above columns into numbers.

from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()

df1[df1_cat_columns] = le.fit_transform(df1_cat_columns)

df1[df1_cat_columns]

"""
OUTPUT:
CarName enginetype fuelsystem
0 0 1 2
1 0 1 2
2 0 1 2
3 0 1 2
4 0 1 2
... ... ... ...
200 0 1 2
201 0 1 2
202 0 1 2
203 0 1 2
204 0 1 2
205 rows × 3 columns
"""

df1.dtypes

"""
OUTPUT:
car_ID                int64
symboling             int64
CarName               int64
fueltype              int64
aspiration            int64
doornumber            int64
carbody               int64
drivewheel            int64
enginelocation        int64
wheelbase           float64
carlength           float64
carwidth            float64
carheight           float64
curbweight            int64
enginetype            int64
cylindernumber        int64
enginesize            int64
fuelsystem            int64
boreratio           float64
stroke              float64
compressionratio    float64
horsepower            int64
peakrpm               int64
citympg               int64
highwaympg            int64
price               float64
"""

Now, all our categorical columns are converted into numerical columns.

We are good to move to the next step.

Splitting the Dataset into Features and Label

The “price” is what we want to predict.

The “car_ID” column is useless so let’s remove that from the feature as well.

y = df1['price']
X = df1.drop(columns=['price', 'car_ID'])

Now, we can do the train test split.

Train Test Split

We are going to use 80% from training and 20% for testing.

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=786)

Splitting is done.

You can check the shape of X_train, X_test, y_train, and y_test using the .shape attribute.

It’s time to get into the interesting part.

Model Building and Evaluation

We are going to build 4 models.

Decision Tree Regressor
Random Forest Regressor
XGB Regressor
Linear Regression

Let’s build them one by one and check which one performs the best.

Decision Tree Regressor

from sklearn.tree import DecisionTreeRegressor

dtr = DecisionTreeRegressor()
dtr.fit(X_train, y_train)
dtr_prediction = dtr.predict(X_test)

from sklearn.metrics import mean_absolute_error, r2_score

dtr_mae = mean_absolute_error(y_test, dtr_prediction)
dtr_mae # 2058.731707317073

dtr_r2 = r2_score(y_test, dtr_prediction)
dtr_r2 # 0.9083297403801555

Not bad. Decision Tree Regressor is giving us a Mean Absolute Error of 2058 which means if the original price is 12058 our model’s prediction price will be 10000. (It’s just 12058–10000 = 2058(mae)).

Let’s create an amazing and interactive scatter plot that will tell us the difference between the actual price and the predicted price for each point in the dataset.

We will be using plotly.express to create our plot.

import plotly.express as px

fig = px.scatter(x=y_test, y=dtr_prediction, labels={'x': 'Actual Price', 'y': 'Predicted Price'}, title='Decision Tree Regressor Model Prediction')
fig.show()

When you hover over the points in the plot you will be able to see what is the actual price and what is the predicted price. See below screen shot.

These are the same steps that we are going to use for all the remaining 3 models.

Random Forest Regressor

from sklearn.ensemble import RandomForestRegressor
rfr = RandomForestRegressor()
rfr.fit(X_train, y_train)
rfr_prediction = rfr.predict(X_test)

rfr_mae = mean_absolute_error(y_test, rfr_prediction)
rfr_mae # 1341.689531707317

rfr_r2 = r2_score(y_test, rfr_prediction)
rfr_r2 # 0.9558504366285837

Random Forest Regressor is performing better than Decision Tree Regressor.

(Note: The mae and r2 may differ for you, if you used different random_state, during the train_test_split or performed some operations differently from me but that totally fine.)

Let’s plot.

fig = px.scatter(x=y_test, y=rfr_prediction, labels={'x': 'Actual Price', 'y': 'Predicted Price'},  title='Random Forest Regressor Model Prediction')
fig.show()

XGB Regressor

from xgboost import XGBRegressor

xgbr = XGBRegressor()
xgbr.fit(X_train, y_train)
xgbr_prediction = xgbr.predict(X_test)

xgbr_mae = mean_absolute_error(y_test, xgbr_prediction)
xgbr_mae # 1636.5274747522865

xgbr_r2 = r2_score(y_test, xgbr_prediction)
xgbr_r2 # 0.9343254539853002

fig = px.scatter(x=y_test, y=xgbr_prediction, labels={'x': 'Actual Price', 'y': 'Predicted Price'}, title='XGB Regressor Model Prediction')
fig.show()

Linear Regression

from sklearn.linear_model import LinearRegression

lr = LinearRegression()
lr.fit(X_train, y_train)
lr_prediction = lr.predict(X_test)

lr_mae = mean_absolute_error(y_test, lr_prediction)
lr_mae # 2891.3739057538883

lr_r2 = r2_score(y_test, lr_prediction)
lr_r2 # 0.8124290725000003

fig = px.scatter(x=y_test, y=lr_prediction, labels={'x': 'Actual Price', 'y': 'Predicted Price'}, title='Linear Regression Model Prediction')
fig.show()

That’s it.

I hope you learned something you didn’t know previously.

P.S: The Universe hates people who are lazy and who wastes time.

0 comments

Rock Vs Mine Prediction Using Machine Learning;

Project-2: Breast Cancer Prediction Using Machine Learning;

Project-1: Big Mart Sales Prediction Using Machine Learning;

NumPy Crash Is Now FREE;

How To Make Money Using Social Media;

See all posts from Abbas Ali