catboost is a high-performance gradient-boosting method created for machine learning applications, specifically ones that need structured input. gradient boosting forms the foundation of its main process. usually, catboost begins by making assumptions about the mean of the target variable.

the next stage is to progressively build the ensemble of decision trees, with each tree seeking to remove the residuals or errors from the previous one. catboost is different in the way it handles categorical features. catboost uses a technique called "ordered boosting" to evaluate category input directly, improving model performance and simplifying training.

additionally, regularization methods are used to prevent overfitting. catboost combines calculated values from every tree to create predictions, generating highly precise and stable models. also, it provides feature relevance scores to help with understanding of feature and model selections. catboost is a valuable tool for a number of machine-learning problems like regression and classification.

so let us see how we can train the catboost model in this chapter −

implementation using catboost

to use catboost you need to install it in your system. to install you can use 'pip install catboost'. type this command on your terminal and the package will be installed automatically.

import required libraries and dataset

so you have to import the required libraries to build your model. also we are using placement dataset to build our model in this chapter. so will load the data into the pandas dataframe and display it using the pd.read_csv() function. let us see how we can do this −

import pandas as pd
import numpy as np
import seaborn as sb
import matplotlib.pyplot as plt

from sklearn.preprocessing import standardscaler
from sklearn.model_selection import train_test_split
from catboost import catboostclassifier
from sklearn.metrics import roc_auc_score as ras

import warnings
warnings.filterwarnings('ignore')

# load you dataset here
df = pd.read_csv('placementdata.csv')
print(df.head())

output

this code will produce the following outcome −

   studentid  cgpa  internships  projects  workshops/certifications  \
0          1   7.5            1         1                         1   
1          2   8.9            0         3                         2   
2          3   7.3            1         2                         2   
3          4   7.5            1         1                         2   
4          5   8.3            1         2                         2   

   aptitudetestscore  softskillsrating extracurricularactivities  \
0                 65               4.4                        no   
1                 90               4.0                       yes   
2                 82               4.8                       yes   
3                 85               4.4                       yes   
4                 86               4.5                       yes   

  placementtraining  ssc_marks  hsc_marks placementstatus  
0                no         61         79       notplaced  
1               yes         78         82          placed  
2                no         79         80       notplaced  
3               yes         81         80          placed  
4               yes         74         88          placed

if we take the time to look at the data above, we can see that this dataset contains information about the students' academic, training, and placement status.

shape and info of the dataset

let us now find out the structure and information of the dataset in order to calculate the total number of data entries that have been given. the content of each column, the data types that are present in it, and the amount of null values that are present in each column can all be seen by using the df.info() method.

# shape of the dataset
df.shape

# information of the dataset
df.info()

output

this will result in the following outcome −

(10000, 12)

<class 'pandas.core.frame.dataframe'>
rangeindex: 10000 entries, 0 to 9999
data columns (total 12 columns):
 #   column                     non-null count  dtype  
---  ------                     --------------  -----  
 0   studentid                  10000 non-null  int64  
 1   cgpa                       10000 non-null  float64
 2   internships                10000 non-null  int64  
 3   projects                   10000 non-null  int64  
 4   workshops/certifications   10000 non-null  int64  
 5   aptitudetestscore          10000 non-null  int64  
 6   softskillsrating           10000 non-null  float64
 7   extracurricularactivities  10000 non-null  object 
 8   placementtraining          10000 non-null  object 
 9   ssc_marks                  10000 non-null  int64  
 10  hsc_marks                  10000 non-null  int64  
 11  placementstatus            10000 non-null  object 
dtypes: float64(2), int64(7), object(3)
memory usage: 937.6+ kb

the dataframe df is statistically represented by the df.describe() function. key statistics, like count, mean, standard deviation, minimum, and maximum values, are given for each numerical column to give an initial understanding of the data distribution and primary patterns.

df.describe().t

output

this code will produce the following outcome −

exploratory data analysis(eda)

eda is a data analysis technique that uses visualizations. it is used to identify trends and patterns as well as to confirm conclusions with the use of statistical reports and graphical representations. while performing the eda on this dataset, we will try to find out the relationship that is, how one effects the other between the independent features.

let us start by taking a quick look at the null values in each column of the data frame.

df.isnull().sum()

output

this code will generate the below outcome −

studentid                    0
cgpa                         0
internships                  0
projects                     0
workshops/certifications     0
aptitudetestscore            0
softskillsrating             0
extracurricularactivities    0
placementtraining            0
ssc_marks                    0
hsc_marks                    0
placementstatus              0
dtype: int64

since there are no null values in the dataset, we can continue with the data exploration.

target class distributions

temporary = df['placementstatus'].value_counts()

plt.pie(temporary.values, labels=temporary.index.values,
	shadow=true, startangle=90, autopct='%1.1f%%')
plt.title("target class distributions")

plt.show()

output

the pie chart below displays the approximately balanced class distribution of the dataset. while this may not be perfect, it is still acceptable. the dataset includes both category and number columns, as we can see. let us divide the dataset into two lists before we look at these attributes.

divide the columns

now we will be dividing the columns of a dataframe (df) in two main categories- categorical columns and numerical columns.

categorical_columns, numerical_columns = list(), list()

for col in df.columns:
   if df[col].dtype == 'object' or df[col].nunique() < 10:
      categorical_columns.append(col)
   else:
      numerical_columns.append(col)

print('categorical columns:', categorical_columns)
print('numerical columns:', numerical_columns)

output

this code will produce the following outcome −

categorical columns: ['internships', 'projects', 'workshops/certifications', 'extracurricularactivities', 'placementtraining', 'placementstatus']
numerical columns: ['studentid', 'cgpa', 'aptitudetestscore', 'softskillsrating', 'ssc_marks', 'hsc_marks']

countplot for categorical columns

now we will create countplot for the categorical columns with the help of the hue of placement status.

plt.subplots(figsize=(15, 15))

for i, col in enumerate(categorical_columns):
   plt.subplot(3, 2, i+1)
   sb.countplot(data=df, x=col, hue='placementstatus', palette='set1') 
plt.tight_layout()
plt.show()

output

the charts provided shown below show multiple patterns that support the idea that focusing on your skill development will surely help with your placement. while it is true that some students have completed training courses and projects and are still not placed, this is a relatively small number in comparison to those who have done nothing.

label encoding of categorical columns

after the encoding of the dataset's categorical features, we will create a heatmap that will help in identifying the highly correlated characteristics inside the feature space with the target columns.

for col in ['extracurricularactivities', 'placementtraining']:
   df[col] = df[col].map({'no':0,'yes':1})
     
df['placementstatus']=df['placementstatus'].map({'notplaced':0, 'placed':1})

confusion matrix

now we will create the confusion matrix for the above dataset.

sb.heatmap(df.corr(), fmt='.1f', cbar=true, annot=true, cmap='coolwarm')  
plt.show()

output

the below outcome shows that there is no data leakage because the dataset does not contain any highly connected or correlated features.

train and validations data split

let us divide the dataset in an 85:15 ratio in order to figure out the model's performance during training. this allows us evaluate the model's performance using the validation split's unseen dataset.

features = df.drop(['studentid', 'placementstatus'], axis=1)
target = df['placementstatus']
 
x_train, x_val, y_train, y_val = train_test_split(
   features, 
   target,
   random_state=2023,
   test_size=0.15)
 
x_train.shape, x_val.shape

output

this will bring about the following outcome −

((8500, 10), (1500, 10))

feature scaling

this code fits the standardscaler to the training data in order to compute the mean and standard deviation, providing consistent scaling between the two datasets. after that it uses these computed values to convert the training and validation data.

scaler = standardscaler()
scaler.fit(x_train)
x_train = scaler.transform(x_train)
x_val = scaler.transform(x_val)

build and train the model

we can now start training the model with the available training data. since there are only two possible values in the target columns, y_train and y_val, binary classification is being performed in this case. separate specifications are not needed whether the model is being trained for a binary or multi-class classification task.

ourmodel = catboostclassifier(verbose=100,
	iterations=1000,
	loss_function='logloss',
	early_stopping_rounds=50,
	custom_metric=['auc'])

ourmodel.fit(x_train, y_train,
	eval_set=(x_val, y_val))

y_train = ourmodel.predict(x_train)
y_val = ourmodel.predict(x_val)

output

this will lead to the following outcome −

learning rate set to 0.053762
0:	learn: 0.6621705	test: 0.6623146	best: 0.6623146 (0)	total: 64.3ms	remaining: 1m 4s
100:	learn: 0.3975289	test: 0.4332971	best: 0.4332174 (92)	total: 230ms	remaining: 2.05s
stopped by overfitting detector  (50 iterations wait)

besttest = 0.4330066724
bestiteration = 125

shrink model to first 126 iterations.

evaluate model's performance

now let us use the roc auc measure to evaluate the model's performance on the training and validation data sets.

print("training roc auc: ", ras(y_train, y_train))
print("validation roc auc: ", ras(y_val, y_val))

output

this will bring about the following outcome −

training roc auc:  0.8175316989019953
validation roc auc:  0.7859439713002392

Save or share this article