Placement Prediction Using Machine Learning

The application of machine learning has grown in popularity in today's fast-paced society as technology has permeated every aspect of our lives. Placement prediction is one of the numerous uses of machine learning. Using machine learning algorithms, placement prediction determines the likelihood that a student will be hired by a firm based on a variety of criteria, including academic achievement, skill set, and prior job experience.

Working of Placement Prediction Using Machine Learning

In order to anticipate placement, information is gathered from a variety of sources, including academic transcripts, resumes, and prior job experience.
After that, this data is cleansed and preprocessed to remove any discrepancies or mistakes.
After being cleaned, the data is divided into two categories: training data and testing data.
The machine learning algorithm is trained using the training data, and its effectiveness is assessed using the testing data. The system is taught using a variety of methods, including neural networks, decision trees, and regression analysis.

A statistical method for determining the relationship between two or more variables is regression analysis. Regression analysis is used in placement prediction to determine the link between numerous variables, including academic achievement, skill set, prior job experience, and the likelihood of being hired by a firm.

A sort of machine learning algorithm known as a decision tree models decisions and potential outcomes using a tree-like structure. Decision trees are employed in the placement prediction scenario to simulate the hiring process decision-making of businesses.

The structure and operation of the human brain served as the inspiration for the machine learning algorithm known as neural networks. Neural networks are used in placement prediction to represent the intricate connections between many elements that influence the likelihood of being hired by a firm.

The algorithm is tested using the testing data once it has been trained to assess its performance. The algorithm's effectiveness is evaluated using a number of measures, including accuracy, precision, recall, and F1 score. These metrics give a sense of how effective the algorithm is in predicting a student's placement likelihood.

Advantages of Employing Machine Learning for Placement Prediction

There are various advantages of using machine learning algorithms to anticipate placement.

Automating the preliminary screening of candidates cuts down on the time and work needed for the hiring process.
It offers a recruiting process that is more data-driven and objective, minimizing the influence of subjectivity and prejudice.
It gives businesses a chance to find people they would have missed via conventional hiring procedures.

Code Impelementation

Here we try to implement machine learning techniques and methods to find out the relation and patterns of the student who got placed and who did not.

1. Importing Libraries

import numpy as np
import pandas as pd

import matplotlib.pyplot as plt
import plotly.express as px
from plotly.offline import init_notebook_mode, iplot
init_notebook_mode(connected=True)

from sklearn.decomposition import PCA

from sklearn. preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import GridSearchCV, RandomizedSearchCV

from sklearn.metrics import accuracy_score
from sklearn.metrics import precision_score, recall_score, f1_score

import pickle

2. Reading the Dataset

dataframe = pd.read_csv('/kaggle/input/engineering-placements-prediction/collegePlace.csv')

# Getting to know the shape of data
dataframe.shape

Output:

We have 2966 rows with 8 features.

# Showing the first 5 rows of the dataset
dataframe.head()

Output:

# Showing 4 rows of the dataset at random
dataframe.sample(4)

Output:

# Getting to know the data type of columns that are in the dataset
dataframe.dtypes

Output:

# Getting to know the detailed information of the columns
dataframe.info()

Output:

# Statistical Descriptions of the numerical values in the dataset
dataframe.describe()

Output:

# Getting to know the correlation between the target column and other features.
dataframe.corr()['PlacedOrNot']

Output:

PlacedOrNot is mostly correlated to the CGPA of the student.

3. Preprocessing

Preprocessing is an important step in machine learning, which means having the data ready and clean before feeding it to the algorithm for learning. Preprocessing is the process of converting raw data into a format appropriate for analysis and modeling.

Now, we will be checking if there are any missing or duplicate values in the dataset.

# missing values
dataframe.isnull().sum()

Output:

# duplicate rows
print(dataframe.duplicated().sum())

#drop duplicates
dataframe.drop_duplicates(inplace=True)

Output:

# Check if the duplicate rows are removed
print(dataframe.duplicated().sum())

Output:

4. EDA

Exploratory data analysis is an important stage in machine learning, which involves examining and visualizing the data to learn more about its composition, traits, and trends. It is carried out prior to developing the actual machine learning model and is crucial for spotting possible difficulties and choosing the right preprocessing and feature engineering strategies.

# Plotting  the graph so that we can visualize the output with respect to major features
figure = px.scatter(dataframe, x="CGPA", y="Internships", color="PlacedOrNot",
                 hover_data=['CGPA'])
figure.show()

Output:

# Plotting Histogram for the count of place and not placed
px.histogram(dataframe, x='PlacedOrNot', color='PlacedOrNot', barmode='group')

Output:

# Pie Chart: Percentage pie chart of Placed or Not Placed
figure = px.pie(dataframe, values=dataframe['PlacedOrNot'].value_counts().values, names=dataframe['PlacedOrNot'].value_counts().index, title='Placed Vs Not Placed')
figure.show()

Output:

# Printing the Age of the youngest and Eldest student who is placed
print("Max Age of Placed Person: ",dataframe[(dataframe['Age'] == dataframe['Age'].max()) & (dataframe['PlacedOrNot']==1)]['Age'].values[0])
print("Min Age of Placed Person: ",dataframe[(dataframe['Age'] == dataframe['Age'].min()) & (dataframe['PlacedOrNot']==1)]['Age'].values[0])

Output:

# Printing the Maximum and the Minimum number of internships done by the student who is placed. 
We will also print the Maximum and Minimum number of students who did the max internship and the minimum number of internships.
print("Max Internships Done by the Placed Student: ",dataframe[(dataframe['Internships'] == dataframe['Internships'].max()) & (dataframe['PlacedOrNot']==1)]['Internships'].values[0])
print("No of students who did max Internships and are placed: ",dataframe[(dataframe['Internships'] == dataframe['Internships'].max()) & (dataframe['PlacedOrNot']==1)]['Internships'].value_counts().values[0])

print("Min Internships Done by the Placed Person: ",dataframe[(dataframe['Internships'] == dataframe['Internships'].min()) & (dataframe['PlacedOrNot']==1)]['Internships'].values[0])
print("No of students who did min Internships and are placed: ",dataframe[(dataframe['Internships'] == dataframe['Internships'].min()) & (dataframe['PlacedOrNot']==1)]['Internships'].value_counts().values[0])

Output:

# Printing the Maximum and Minimum number of CGPA obtained by the student who is placed.
# We will also print the Maximum and the Minimum number of students who got the max CGPA and minimum CGPA who are placed.

print("Max CGPA of Placed Student: ",dataframe[(dataframe['CGPA'] == dataframe['CGPA'].max()) & (dataframe['PlacedOrNot']==1)]['CGPA'].values[0])
print("No of students has max CGPA and are placed: ",dataframe[(dataframe['CGPA'] == dataframe['CGPA'].max()) & (dataframe['PlacedOrNot']==1)]['CGPA'].value_counts().values[0])

print("Min CGPA of Placed Person: ",dataframe[(dataframe['CGPA'] == dataframe['CGPA'].min()) & (dataframe['PlacedOrNot']==1)]['CGPA'].values[0])
print("No of students has min CGPA and are placed: ",dataframe[(dataframe['CGPA'] == dataframe['CGPA'].min()) & (dataframe['PlacedOrNot']==1)]['CGPA'].value_counts().values[0])

Output:

5. Representation

The process of statistical representation involves using statistical measures and visualizations to present data in a meaningful and understandable manner with the main objective of enabling the user to understand insights and patterns in the data and make well-informed decisions using the data.

figure = px.box(dataframe, y='CGPA')
figure.show()

Output:

figure = px.box(dataframe, y='Age')
figure.show()

Output:

figure = px.box(dataframe, y=['Internships','CGPA', 'Age'])
figure.show()

Output:

6. Encoding Categorical to Numerical

In machine learning, encoding categorical variables to numeric variables is a typical preprocessing step. It requires changing a qualitative attribute-representing category variable into a numerical variable that may be employed in mathematical operations and models.

# Converting Gender column
dataframe['Gender'] = dataframe['Gender'].map({'Male': 1, 'Female': 0})

Output:

# Converting Stream column
dataframe['Stream'] = dataframe['Stream'].map({'Electronics And Communication': 1,
                                 'Computer Science': 2,
                                'Information Technology': 3,
                                'Mechanical':4,
                                'Electrical':5,
                                'Civil':6})

Output:

7. Extracting Input and Output Columns

X = dataframe.iloc[:,0:7]
y = dataframe.iloc[:,-1]
X

Output:

# Getting the shape of the X and Y
print(X.shape)
print(y.shape)

Output:

# Splitting the dataset into training and testing datasets.
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.33)

# Getting the Shape of all the training and testing dataset
print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)

Output:

9. Scaling the Values

scaler = StandardScaler()
X_train_scale = scaler.fit_transform(X_train)
X_test_scale = scaler.transform(X_test)

10. Training & Evaluating the Model

Training and evaluating the model are the two critical steps in machine learning that determine the accuracy and performance of the model. These steps require careful planning, attention to detail, and rigorous evaluation to develop a model that can generalize well to new, unseen data.

Here will go with different machine learning algorithms and find their accuracy.

1. Logistic Regression

from sklearn.linear_model import LogisticRegression
classifier = LogisticRegression()

# Without Scaling
classifier.fit(X_train,y_train)
y_pred = classifier.predict(X_test)
print("Without Scaling and CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train, y_train, cv=10)
print("Without Scaling and With CV: ",scores.mean())

# With Scaling
classifier.fit(X_train_scale,y_train)
y_pred = classifier.predict(X_test_scale)
print("With Scaling and Without CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train_scale, y_train, cv=10)
print("With Scaling and With CV: ",scores.mean())

#scaling has not much effect

Output:

2. Decision Tree Classifier

from sklearn.tree import DecisionTreeClassifier
classifier = DecisionTreeClassifier(random_state=0)

#without scaling
classifier.fit(X_train,y_train)
y_pred = classifier.predict(X_test)
print("Without Scaling and CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train, y_train, cv=10)
print("Without Scaling and With CV: ",scores.mean())

# With Scaling
classifier.fit(X_train_scale,y_train)
y_pred = classifier.predict(X_test_scale)
print("With Scaling and Without CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train_scale, y_train, cv=10)
print("With Scaling and With CV: ",scores.mean())

Output:

3. Random Forest Classifier

from sklearn.ensemble import RandomForestClassifier

classifier = RandomForestClassifier(max_depth=10, random_state=0)

classifier.fit(X_train,y_train)
y_pred = classifier.predict(X_test)
print("Without Scaling and CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train, y_train, cv=10)
print("Without Scaling and With CV: ",scores.mean())

# With Scaling
classifier.fit(X_train_scale,y_train)
y_pred = classifier.predict(X_test_scale)
print("With Scaling and Without CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train_scale, y_train, cv=10)
print("With Scaling and With CV: ",scores.mean())

Output:

4. Support Vector Machines

from sklearn.svm import SVC

svc = SVC()
parameters = {'kernel':('linear', 'rbf'), 'C':[1, 10]}
classifier = GridSearchCV(svc, parameters)

classifier.fit(X_train,y_train)
y_pred = classifier.predict(X_test)
print("Without Scaling and CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train, y_train, cv=10)
print("Without Scaling and With CV: ",scores.mean())

# With Scaling
classifier.fit(X_train_scale,y_train)
y_pred = classifier.predict(X_test_scale)
print("With Scaling and Without CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train_scale, y_train, cv=10)
print("With Scaling and With CV: ",scores.mean())

Output:

from sklearn.svm import NuSVC
classifier = NuSVC()

classifier.fit(X_train,y_train)
y_pred = classifier.predict(X_test)
print("Without Scaling and CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train, y_train, cv=10)
print("Without Scaling and With CV: ",scores.mean())

# With Scaling
classifier.fit(X_train_scale,y_train)
y_pred = classifier.predict(X_test_scale)
print("With Scaling and Without CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train_scale, y_train, cv=10)
print("With Scaling and With CV: ",scores.mean())

Output:

5. Naive Bayes

from sklearn.naive_bayes import GaussianNB
classifier = GaussianNB()

classifier.fit(X_train,y_train)
y_pred = classifier.predict(X_test)
print("Without Scaling and CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train, y_train, cv=10)
print("Without Scaling and With CV: ",scores.mean())

# With Scaling
classifier.fit(X_train_scale,y_train)
y_pred = classifier.predict(X_test_scale)
print("With Scaling and Without CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train_scale, y_train, cv=10)
print("With Scaling and With CV: ",scores.mean())

Output:

from sklearn.naive_bayes import MultinomialNB
classifier = MultinomialNB()

classifier.fit(X_train,y_train)
y_pred = classifier.predict(X_test)
print("Without Scaling and CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train, y_train, cv=10)
print("Without Scaling and With CV: ",scores.mean())

Output:

from sklearn.naive_bayes import BernoulliNB
classifier = BernoulliNB()

classifier.fit(X_train,y_train)
y_pred = classifier.predict(X_test)
print("Without Scaling and CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train, y_train, cv=10)
print("Without Scaling and With CV: ",scores.mean())

# With Scaling
classifier.fit(X_train_scale,y_train)
y_pred = classifier.predict(X_test_scale)
print("With Scaling and Without CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train_scale, y_train, cv=10)
print("With Scaling and With CV: ",scores.mean())

Output:

from sklearn.naive_bayes import CategoricalNB
classifier = CategoricalNB()

classifier.fit(X_train,y_train)
y_pred = classifier.predict(X_test)
print("Without Scaling and CV: ",accuracy_score(y_test,y_pred))

Output:

6. KNN

from sklearn.neighbors import KNeighborsClassifier
classifier = KNeighborsClassifier(n_neighbors=3)

classifier.fit(X_train,y_train)
y_pred = classifier.predict(X_test)
print("Without Scaling and CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train, y_train, cv=10)
print("Without Scaling and With CV: ",scores.mean())


# With Scaling
classifier.fit(X_train_scale,y_train)
y_pred = classifier.predict(X_test_scale)
print("With Scaling and Without CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train_scale, y_train, cv=10)
print("With Scaling and With CV: ",scores.mean())

Output:

11. SGD Classifiers

from sklearn.linear_model import SGDClassifier
classifier = SGDClassifier(max_iter=1000, tol=1e-3)

# Without Scaling
classifier.fit(X_train,y_train)
y_pred = classifier.predict(X_test)
print("Without Scaling and CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train, y_train, cv=10)
print("Without Scaling and With CV: ",scores.mean())

# With Scaling
classifier.fit(X_train_scale,y_train)
y_pred = classifier.predict(X_test_scale)
print("With Scaling and Without CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train_scale, y_train, cv=10)
print("With Scaling and With CV: ",scores.mean())

Output:

from sklearn.linear_model import Perceptron

classifier = Perceptron(tol=1e-3, random_state=0)
# Without Scaling
classifier.fit(X_train,y_train)
y_pred = classifier.predict(X_test)
print("Without Scaling and CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train, y_train, cv=10)
print("Without Scaling and With CV: ",scores.mean())

# With Scaling
classifier.fit(X_train_scale,y_train)
y_pred = classifier.predict(X_test_scale)
print("With Scaling and Without CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train_scale, y_train, cv=10)
print("With Scaling and With CV: ",scores.mean())

Output:

from sklearn.linear_model import LogisticRegressionCV
classifier = LogisticRegressionCV(cv=5, random_state=0)

# Without Scaling
classifier.fit(X_train,y_train)
y_pred = classifier.predict(X_test)
print("Without Scaling and CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train, y_train, cv=10)
print("Without Scaling and With CV: ",scores.mean())

# With Scaling
classifier.fit(X_train_scale,y_train)
y_pred = classifier.predict(X_test_scale)
print("With Scaling and Without CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train_scale, y_train, cv=10)
print("With Scaling and With CV: ",scores.mean())

Output:

Model Selection

So the best accuracy among the models is of Random Forest Classifier.

classifier = RandomForestClassifier(max_depth=10, random_state=0)
classifier.fit(X_train,y_train)
y_pred = classifier.predict(X_test)
print("Without CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train, y_train, cv=10)
print("With CV: ",scores.mean())
print("Precision Score: ", precision_score(y_test, y_pred))
print("Recall Score: ", recall_score(y_test, y_pred))
print("F1 Score: ", f1_score(y_test, y_pred))

Output:

Tuning the Model

Using Hyper-Parameter tuning using GridsearchCV, Hypertune the parameters for Random forest and get the best parameters.

param_grid = {
    'bootstrap': [False,True],
    'max_depth': [5,8,10, 20],
    'max_features': [3, 4, 5, None],
    'min_samples_split': [2, 10, 12],
    'n_estimators': [100, 200, 300]
}

rfclassifier = RandomForestClassifier()

classifier = GridSearchCV(estimator = rfclassifier, param_grid = param_grid, cv = 5, n_jobs = -1, verbose = 1)

classifier.fit(X_train,y_train)
y_pred = classifier.predict(X_test)
print("Accuracy: ",accuracy_score(y_test,y_pred))
print(classifier.best_params_)
print(classifier.best_estimator_)

Output:

Checking the accuracy of the model with the best parameters

classifier = RandomForestClassifier(bootstrap=False, max_depth=5,max_features=None,
                             min_samples_split=2,
                             n_estimators=100, random_state=0)
classifier.fit(X_train,y_train)
y_pred = classifier.predict(X_test)
print("Without CV: ",accuracy_score(y_test,y_pred))
scores = cross_val_score(classifier, X_train, y_train, cv=10)
print("With CV: ",scores.mean())
print("Precision Score: ", precision_score(y_test, y_pred))
print("Recall Score: ", recall_score(y_test, y_pred))
print("F1 Score: ", f1_score(y_test, y_pred))

Output:

The accuracy of the model with CV is 83%, and without CV is 80%.

We can say that the accuracy of the model that we created is quite high.

Conclusion

The likelihood that a student will be hired by a firm may be predicted using placement prediction utilizing machine learning techniques. The application of machine learning algorithms offers a more data-driven and objective approach to the hiring process, allowing businesses to find potential applicants who would have gone unnoticed using conventional hiring techniques. Machine learning is becoming more and more prevalent across a wide range of sectors, and placement prediction using machine learning algorithms is poised to become a crucial tool in the hiring process.

Next TopicStock Market prediction using Machine Learning

← prev next →