DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

BONAFIDECERTIFICATE

Name of the Student:

Register No.

This is to certify that this is a bonafide record of the workdone by the above student with
RollNo. of Semester B.E
Degree in in
the during Laboratory
the academic year 2022 – 2023.

Staff-In-Charge Head of the Dept.

Date:

Submitted for the Practical Examination held on

Internal Examiner External Examiner

 CS3461- OPERATING SYSTEMS LABORATORY
INDEX

EX.NO. DATE NAME OF THE EXPERIMENT MARKS SIGN

 PROGRAM 1:

IMPLEMENT NAIVE BAYES THEOREM TO CLASSIFY THE ENGLISH TEXT:

AIM:
To Implement naive bayes theorem to classify the English text

DESCRIPTION:

The challenge of text classification is to attach labels to bodies of text, e.g., tax document, medical
form, etc. based on the text itself. For example, think of your spam folder in your email. How does your
email provider know that a particular message is spam or “ham” (not spam)? We’ll take a look at one
natural language processing technique for text classification called Naive Bayes.

SOURCE CODE:

import pandas as pd

fromsklearn.model_selection import train_test_split

fromsklearn.feature_extraction.text import CountVectorizer

fromsklearn.naive_bayes import MultinomialNB

fromsklearn.metrics import accuracy_score, confusion_matrix, precision_score, recall_score

msg = pd.read_csv('document.csv', names=['message', 'label'])

print("Total Instances of Dataset: ", msg.shape[0])

msg['labelnum'] = msg.label.map({'pos': 1, 'neg': 0})

X = msg.message

y = msg.labelnum

Xtrain, Xtest, ytrain, ytest = train_test_split(X, y)

count_v = CountVectorizer()

Xtrain_dm = count_v.fit_transform(Xtrain)

Xtest_dm = count_v.transform(Xtest)

df = pd.DataFrame(Xtrain_dm.toarray(),columns=count_v.get_feature_names())
clf = MultinomialNB()

clf.fit(Xtrain_dm, ytrain)

pred = clf.predict(Xtest_dm)

print('Accuracy Metrics:')

print('Accuracy: ', accuracy_score(ytest, pred)) print('Recall: ', recall_score(ytest, pred)) print('Precision: ',

precision_score(ytest, pred))

print('Confusion Matrix: \n', confusion_matrix(ytest, pred))

document.csv:
I love this sandwich,pos This

is an amazingplace,pos

I feel very good about these beers,pos

This is my best work,pos

What an awesome view,pos

I do not like this restaurant,neg

I am tired of this stuff,neg

I can't deal with this,neg He

is my sworn enemy,neg My

boss is horrible,neg

This is an awesome place,pos

I do not like the taste of this juice,neg

I love to dance,pos

I am sick and tired of this place,neg

What a great holiday,pos

That is a bad locality to stay,neg

We will have good fun tomorrow,pos I

went to my enemy's house today,neg

OUTPUT:
Total Instances of Dataset: 18

Accuracy Metrics: Accuracy: 0.6

Recall: 0.6666666666666666

Precision: 0.6666666666666666

Confusion Matrix:

[[1 1]

[1 2]]
VIVA QUESTIONS & ANSWERS:

1. How Naive Bayes algorithm works?

Let’s understand it using an example. Below I have a training data set of weather and
corresponding target variable ‘Play’ (suggesting possibilities of playing). Now, we need to classify
whether players will play or not based on weather condition. Let’s follow the below steps to perform it.

Step 1: Convert the data set into a frequency table

Step 2: Create Likelihood table by finding the probabilities like Overcast probability = 0.29 and
probability of playing is 0.64.

Step 3: Now, use Naive Bayesian equation to calculate the posterior probability for each class. The class
with the highest posterior probability is the outcome of prediction.

Problem:: Players will play if weather is sunny. Is this statement is correct?

We can solve it using above discussed method of posterior probability.

P(Yes | Sunny) = P( Sunny | Yes) * P(Yes) / P (Sunny)

Here we have P (Sunny |Yes) = 3/9 = 0.33, P(Sunny) = 5/14 = 0.36, P( Yes)= 9/14 = 0.64

Now, P (Yes | Sunny) = 0.33 * 0.64 / 0.36 = 0.60, which has higher probability.
Naive Bayes uses a similar method to predict the probability of different class based on various attributes.
This algorithm is mostly used in text classification and with problems having multiple classes.

2. Applications of Naive Bayes Algorithms:

 Real time Prediction: Naive Bayes is an eager learning classifier and it is sure fast. Thus, it could be
used for making predictions in real time.

 Multi class Prediction: This algorithm is also well known for multi class prediction feature. Here we
can predict the probability of multiple classes of target variable.

 Text classification/ Spam Filtering/ Sentiment Analysis: Naive Bayes classifiers mostly used in text
classification (due to better result in multi class problems and independence rule) have higher success
rate as compared to other algorithms. As a result, it is widely used in Spam filtering (identify spam e-
mail) and Sentiment Analysis (in social media analysis, to identify positive and negative customer
sentiments).

 Recommendation System: Naive Bayes Classifier and Collaborative Filtering together builds a
Recommendation System that uses machine learning and data mining techniques to filter unseen
information and predict whether a user would like a given resource or not.
 PROGRAM 2:

TO IMPLEMENT CLASSIFICATION WITH K-NEAREST NEIGHBORS

AIM:

Write a program to implement classification with K-Nearest Neighbors

DESCRIPTION:

Write a program to implement classification with K-Nearest Neighbors. In this question, you

will use the scikit-learn’s KNN classifier to classify real vs. fake news headlines. The aim of

this question is for you to read the scikit-learn API and get comfortable with training

/validation splits. Use California Housing Datasets.

 Distance Metrics

K-Nearest-Neighbour Algorithm:

L-Load the data

M-Initialize the value of k
N-For getting the predicted class, iterate from 1 to total number of training data points

1. Calculate the distance between test data and each row of training data. Here we will use Euclidean
distance as our distance metric since it’s the most popular method. The other metrics that can be
used are Chebyshev, cosine, etc.
2. Sort the calculated distances in ascending order based on distance values
3. Get top k rows from the sorted array.
4. Get the most frequent class of these rows i.e Get the labels of the selected K entries.
5. Return the predicted class. If regression, return the mean of the K labels If classification,
return the mode of the K labels.
Confusion matrix:

Note;

• Class 1 : Positive
• Class 2 : Negative

• Positive (P) : Observation is positive (for example: is an apple).

• Negative (N) : Observation is not positive (for example: is not an apple).
• True Positive (TP) : Observation is positive, and is predicted to be positive.
• False Negative (FN) : Observation is positive, but is predicted negative. (Also known as a "Type II
error.".
• True Negative (TN) : Observation is negative, and is predicted to be negative.
• False Positive (FP) : Observation is negative, but is predicted positive. (Also known as a "Type I error.").

ACCURACY = TP+TN
------------------
TP+TN+FP+FN

RECALL = TP
-------------------
TP+FN

PRECISION = TP
-------------------
TP+FP

F-MEASURE = 2*RECALL*PRECISION
--------------------------------
RECALL+PRECISION
EXAMPLE:

PREDICTED: PREDICTED:
NO YES
 TN=50 FP=10 60

n=165 FN=5 TP=100 105

ACTUAL = NO 55 110

ACTUAL = YES

Accuracy: Overall, how often is the classifier correct?

(TP+TN)/total = (100+50)/165 = 0.91

Misclassification Rate: Overall, how often is it wrong?

(FP+FN)/total = (10+5)/165 = 0.09
equivalent to 1 minus Accuracy also known as "Error Rate“.

True Positive Rate: When it's actually yes, how often does it predict yes?
TP/actual yes = 100/105 = 0.95
also known as "Sensitivity" or "Recall".

False Positive Rate: When it's actually no, how often does it predict yes?
FP/actual no = 10/60 = 0.17

True Negative Rate: When it's actually no, how often does it predict no?
TN/actual no = 50/60 = 0.83
equivalent to 1 minus False Positive Rate also known as "Specificity“.

Precision: When it predicts yes, how often is it correct?

TP/predicted yes = 100/110 = 0.91.

Prevalence: How often does the yes condition actually occur in our sample?
actual yes/total = 105/165 = 0.64

Source Code:

from sklearn.neighbors import KNeighborsClassifier

from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split

import pandas as pd

dataset=pd.read_csv("iris.csv")
X_train,X_test,y_train,y_test=train_test_split(X,y,random_state=0,test_size=0.25)

classifier=KNeighborsClassifier(n_neighbors=8,p=3,metric='euclidean')

classifier.fit(X_train,y_train)

#predict the test resuts

y_pred=classifier.predict(X_test)

cm=confusion_matrix(y_test,y_pred)
print('Confusion matrix is as follows\n',cm)
print('Accuracy Metrics')
print(classification_report(y_test,y_pred))
print(" correct predicition",accuracy_score(y_test,y_pred))
print(" worng predicition",(1-accuracy_score(y_test,y_pred)))

Output :
Confusion matrix is as follows
[[13 0 0]
[ 0 15 1]
[ 0 0 9]]

Accuracy Metrics:

Precision Recall F1-score Support

Iris-setosa 1.00 1.00 1.00 13
Iris-versicolor 1.00 0.94 0.97 16
Iris-virginica 0.90 1.00 0.95 9
Avg / total 0.98 0.97 0.97 38

Correct Predicition: 0.9736842105263158

Wrong Predicition: 0.02631578947368418
 PROGRAM 3:

IMPLEMENT A LINEAR REGRESSION WITH A REAL DATASET

AIM:

To Implement Linear Regression with a real datasets and Experiment with different features in

building a model. Tune the model's hyper parameters.

DESCRIPTION:

1. Define business object.

2. Make sense of the data from a high level.

 data types (number, text, object, etc.)

 continuous/discrete
 basic stats (min, max, std, median, etc.) using boxplot
 frequency via histogram
 scales and distributions of different features

3. Create the training and test sets using proper sampling methods, e.g., random vs. Stratified.
4. Correlation analysis (pair-wise and attribute combinations).
5. Data cleaning (missing data, outliers, data errors).
6. Data transformation via pipelines (categorical text to number using one hot encoding, feature
scaling via normalization/standardization, feature combinations).
7. Train and cross validate different models and select the most promising one (Linear Regression,
Decision Tree, and Random Forest were tried in this tutorial).
8. Fine tune the model using trying different combinations of hyper parameters.
9. Evaluate the model with best estimators in the test set.
10. Launch, monitor, and refresh the model and system.

SOURCE CODE:

# This Python 3 environment comes with many helpful analytic libraries installed.

# It is defined by the kaggle/python docker image: https://github.com/kaggle/ docker-python.

import numpy as np

import pandas as pd

%matplotlib inline
import matplotlib.pyplot as plt

import seaborn as sns

# Input data files are available in the "../input/" directory.

# For example, running this (by clicking run or pressing Shift+Enter) will list the files in the input
Directory

import os

print(os.listdir("../input"))

# Any results you write to the current directory are saved as output.

['anscombe.csv', 'housing.csv']

# loading data

data_path = "../input/housing.csv"

housing = pd.read_csv(data_path)

# see the basic info

housing.info()

<class 'pandas.core.frame.DataFrame'>

RangeIndex: 20640 entries, 0 to 20639

Data columns (total 10 columns):

longitude 20640 non-null float64

latitude 20640 non-null float64

housing_median_age 20640 non-null float64

total_rooms 20640 non-null float64

total_bedrooms 20433 non-null float64

population 20640 non-null float64

households 20640 non-null float64

median_income 20640 non-null float64

median_house_value 20640 non-null float64

ocean_proximity 20640 non-null object

dtypes: float64(9), object(1)

memory usage: 1.6+ MB

Input(3): housing.head(10)

Input(4): housing.describe()

Input(5): housing.boxplot(['median_house_value'], figsize=(10, 10))

Input(6): housing.hist(bins=50, figsize=(15, 15))

Output(6):
Input(7): housing['ocean_proximity'].value_counts()

Output(7):

<1H OCEAN 9136

INLAND 6551

NEAR OCEAN 2658

NEAR BAY 2290

ISLAND 5

Name: ocean_proximity, dtype: int64

Input(8):

op_count = housing['ocean_proximity'].value_counts()

plt.figure(figsize=(10,5))

sns.barplot(op_count.index, op_count.values, alpha=0.7)

plt.title('Ocean Proximity Summary')

plt.ylabel('Number of Occurrences', fontsize=12)

plt.xlabel('Ocean Proximity', fontsize=12)

plt.show()

# housing['ocean_proximity'].value_counts().hist()

Output(8):
Input(9): housing['median_income'].hist()

Output(9): <matplotlib.axes._subplots.AxesSubplot at 0x7f264523cb00>

Input(10): housing['median_income'].hist()

Output(10): <matplotlib.axes._subplots.AxesSubplot at 0x7f264523cb00>

Input(11):housing.plot(kind='scatter', x='longitude', y='latitude', alpha=0.1)

Output(11): <matplotlib.axes._subplots.AxesSubplot at 0x7f2645224e10>

Input(12):

# Pearson's r, aka, standard correlation coefficient for every pair

corr_matrix = housing.corr()

# Check the how much each attribute correlates with the median house value

corr_matrix['median_house_value'].sort_values(ascending=False)

Output(12):

median_house_value 1.000000

median_income 0.687160

total_rooms 0.135097

housing_median_age 0.114110

households 0.064506

total_bedrooms 0.047689

population -0.026920

longitude -0.047432

latitude -0.142724

Name: median_house_value, dtype: float64.

 PROGRAM 4:

THE SCIKIT-LEARNS’s KNN CLASSIFIER TO CLASSIFY REAL vs. FAKE NEWS

HEADLINES.

AIM:

The aim of this question is for you to read the scikit-learn API and get comfortable with training/validation

splits. Use California Housing Datasets.

DESCRIPTION:

Classification with Nearest Neighbors. In this question, you will use the scikit-learn’s KNN classifier to

classify real vs. fake news headlines. The aim of this question is for you to read the scikit-learn API and get

comfortable with training/validation splits. Use California Housing Datasets.

SOURCE CODE:

import csv

import random

import math

import operator

def loadDataset(filename, split, trainingSet=[] , testSet=[])

:
with open(filename, 'rb') as csvfile
:
lines = csv.reader(csvfile)

dataset = list(lines)

for x in range(len(dataset)-1):

for y in range(4):

dataset[x][y] = float(dataset[x][y])

if random.random() < split: trainingSet.append(dataset[x])

else:

testSet.append(dataset[x])
def euclideanDistance(instance1, instance2, length):

distance = 0

for x in range(length):

distance += pow((instance1[x] - instance2[x]), 2)

return math.sqrt(distance)

def getNeighbors(trainingSet, testInstance, k):

distances = []

length = len(testInstance)-1

for x in range(len(trainingSet)):

dist = euclideanDistance(testInstance, trainingSet[x], length) distances.append((trainingSet[x], dist))

distances.sort(key=operator.itemgetter(1))

neighbors = []

for x in range(k):

neighbors.append(distances[x][0])

return neighbors

def getResponse(neighbors):

classVotes = {}

for x in range(len(neighbors)):

response = neighbors[x][-1]

if response in classVotes:

classVotes[response] += 1

else:

classVotes[response] = 1
sortedVotes =

sorted(classVotes.iteritems(),

reverse=True)

return sortedVotes[0][0]

def getAccuracy(testSet,

predictions): correct = 0

for x in

range(len(testSet)):

key=operator.itemgetter(1);

if testSet[x][-1] == predictions[x]:

correct += 1

return (correct/float(len(testSet))) * 100.0

def main():

# prepare

Data

trainingSet=

[] testSet=[]

split = 0.67

loadDataset('knndat.data', split, trainingSet,

testSet) print('Train set: ' + repr(len(trainingSet)))

print('Test set: ' + repr(len(testSet)))

# generate

predictions

predictions=[]
k=3

for x in range(len(testSet)):

neighbors = getNeighbors(trainingSet, testSet[x],

k) result = getResponse(neighbors)

predictions.append(result)

print('> predicted=' + repr(result) + ', actual=' + repr(testSet[x][-

) accuracy = getAccuracy(testSet, predictions)

print('Accuracy: ' + repr(accuracy) +

1]) '%') main()

OUTPUT:

Confusion matrix is as follows:

[[11 0 0]
[0 9 1]
[0 1 8]]

Accuracy metrics:

0 1.00 1.00 1.00 11

1 0.90 0.90 0.90 10

2 0.89 0.89 0.89 9

Avg/Total: 0.93 0.93 0.93 30.

 PROGRAM 5:

ANALYZE DELTAS BETWEEN TRAINING SET AND VALIDATION SET RESULTS

AIM:

To implement the experiment with validation sets and test sets using the datasets.

DESCRIPTION:

To experiment with validation sets and test sets using the datasets. Split a training set into a smaller

training set and a validation set. Analyze deltas between training set and validation set results. Test the

trained model with a test set to determine whether your trained model is over fitting. Detect and fix a

common training problem.

SOURCE CODE:

import matplotlib.pyplot as plt

import numpy as np

from sklearn.model_selection import cross_validate, train_test_split

from sklearn.preprocessing import Polynomial Features, StandardScaler

from sklearn.pipeline import make_pipeline

from sklearn.linear_model import LinearRegression

from sklearn.metrics import mean_squared_error

np.random.seed(42)

# Generate data and plot

N = 300

x = np.linspace(0, 7*np.pi, N)

smooth = 1 + 0.5*np.sin(x)

y = smooth + 0.2*np.random.randn(N)

plt.plot(x, y)

plt.plot(x, smooth)
plt.xlabel("x")

plt.ylabel("y")

plt.ylim(0,2)

plt.show()

# Train-test split, intentionally use shuffle=False

X = x.reshape(-1,1)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, shuffle=False)

# Create two models: Polynomial and linear regression

degree = 2

polyreg = make_pipeline(Polynomial Features(degree), LinearRegression(fit_intercept=False))

linreg = LinearRegression()

# Cross-validation

scoring = "neg_root_mean_squared_error"

polyscores = cross_validate(polyreg, X_train, y_train, scoring=scoring, return_estimator=True)

linscores = cross_validate(linreg, X_train, y_train, scoring=scoring, return_estimator=True)

# Which one is better? Linear and polynomial

print("Linear regression score:", linscores["test_score"].mean())

print("Polynomial regression score:", polyscores["test_score"].mean())

print("Difference:", linscores["test_score"].mean() - polyscores["test_score"].mean())

print("Coefficients of polynomial regression and linear regression:")

# Let's show the coefficient of the last fitted polynomial regression

# This starts from the constant term and in ascending order of powers

print(polyscores["estimator"][0].steps[1][1].coef_)

# And show the coefficient of the last-fitted linear regression

print(linscores["estimator"][0].intercept_, linscores["estimator"][-1].coef_)

# Plot and compare

plt.plot(x, y)

plt.plot(x, smooth)

plt.plot(x, polyscores["estimator"][0].predict(X))

plt.plot(x, linscores["estimator"][0].predict(X))

plt.ylim(0,2)

plt.xlabel("x")

plt.ylabel("y")

plt.show()

# Retrain the model and evaluate

import sklearn

linreg = sklearn.base.clone(linreg)

linreg.fit(X_train, y_train)

print("Test set RMSE:", mean_squared_error(y_test, linreg.predict(X_test), squared=False))

print("Mean validation RMSE:", -linscores["test_score"].mean()).

OUTPUT:
 PROGRAM 6:

IMPLEMENT A BINARY CLASSIFICATION MODEL

AIM:

Implement a binary classification model. Binary question such as "Are houses in this neighborhood above a

certain price?

DESCRIPTION:

Implement a binary classification model. Binary question such as "Are houses in this neighborhood above a

certain price?"(use data from exercise 1). Modify the classification threshold and determine how that

modification influences the model. Experiment with different classification metrics to determine your

model's effectiveness.

SOURCE CODE:

train_df = pd.read_csv("https://download.mlcc.google.com/mledu datasets/california_housing_train.csv")

test_df = pd.read_csv("https://download.mlcc.google.com/mledu-datasets/california_housing_test.csv")

train_df = train_df.reindex(np.random.permutation(train_df.index))

# shuffle the training set

threshold = 265000 # This is the 75th percentile for median house values.

train_df_norm["median_house_value_is_high"] = ? Your code here

test_df_norm["median_house_value_is_high"] = ? Your code here

# Print out a few example cells from the beginning and

# middle of the training set, just to make sure that

# your code created only 0s and 1s in the newly created

# median_house_value_is_high column

train_df_norm["median_house_value_is_high"].head(8000)

inputs = {

# Features used to train the model on.

 'median_income': tf.keras.Input(shape=(1,)),

'total_rooms': tf.keras.Input(shape=(1,))

# The following variables are the hyperparameters.

learning_rate = 0.001

epochs = 20

batch_size = 100

classification_threshold = 0.35

label_name = "median_house_value_is_high"

# Modify the following definition of METRICS to generate

# not only accuracy and precision, but also recall:

METRICS = [
tf.keras.metrics.BinaryAccuracy(name='accuracy',

threshold=classification_threshold),
tf.keras.metrics.Precision(thresholds=classification_threshold,

name='precision'
),
? # write code here
]

# Establish the model's topography.

my_model = create_model(inputs, learning_rate, METRICS)

# Train the model on the training set.

epochs, hist = train_model(my_model, train_df_norm, epochs,

label_name, batch_size)
# Plot metrics vs. Epochs
list_of_metrics_to_plot = ['accuracy', 'precision', 'recall']

plot_curve(epochs, hist, list_of_metrics_to_plot)

OUTPUT:
 PROGRAM 7:

IMPLEMENT THE FINITE WORDS CLASSIFICATION SYSTEM USING

BACKPROPAGATIONALGORITHM

AIM:

To implement the finite words classification system using Back-propagation algorithm.

DESCRIPTION:

What is back propagation?

We can define the back propagation algorithm as an algorithm that trains some given feed forward Neural

Network for a given input pattern where the classifications are known to us. At the point when every

passage of the example set is exhibited to the network, the network looks at its yield reaction to the

example input pattern. After that, the comparison done between output response and expected output with

the error value is measured. Later, we adjust the connection weight based upon the error value measured.

It was first introduced in the 1960s and 30 years later it was popularized by David Rumelhart,

Geoffrey Hinton, and Ronald Williams in the famous 1986 paper. In this paper, they spoke about the

various neural networks. Today, back propagation is doing good. Neural network training happens through

back propagation. By this approach, we fine-tune the weights of a neural net based on the error rate

obtained in the previous run. The right manner of applying this technique reduces error rates and makes

the model more reliable. Back propagation is used to train the neural network of the chain rule method. In

simple terms, after each feed-forward passes through a network, this algorithm does the backward pass to

adjust the model’s parameters based on weights and biases. A typical supervised learning algorithm

attempts to find a function that maps input data to the right output. Back propagation works with a multi-

layered neural network and learns internal representations of input to output mapping.

The Back propagation algorithm is a supervised learning method for multi layer feed forward

networks from the field of Artificial Neural Networks.

Feed-forward neural networks are inspired by the information processing of one or more neural
cells, called a neuron. A neuron accepts input signals via its dendrites, which pass the electrical signal

down to the cell body. The axon carries the signal out to synapses, which are the connections of a cell’s

axon to other cell’s dendrites.

The principle of the back propagation approach is to model a given function by modifying internal

weightings of input signals to produce an expected output signal. The system is trained using a supervised

learning method, where the error between the system’s output and a known expected output is presented to

the system and used to modify its internal state.

Technically, the back propagation algorithm is a method for training the weights in a multilayer

feed-forward neural network. As such, it requires a network structure to be defined of one or more layers

where one layer is fully connected to the next layer. A standard network structure is one input layer, one

hidden layer, and one output layer.Back propagation can be used for both classification

and regression problems.

In classification problems, best results are achieved when the network has one neuron in the output

layer for each class value. For example, a 2-class or binary classification problem with the class values of

A and B. These expected outputs would have to be transformed into binary vectors with one column for

each class value. Such as [1, 0] and [0, 1] for A and B respectively. This is called a one hot encoding.

How does back propagation work?

Let us take a look at how back propagation works. It has four layers: input layer, hidden layer,

hidden layer II and final output layer. So, the main three layers are:

1. Input layer

2. Hidden layer

3. Output layer.

Each layer has its own way of working and its own way to take action such that we are able to get the

desired results and correlate these scenarios to our conditions. Let us discuss other details needed to help

summarizing this algorithm.

SOURCE CODE:

import pandas as pd

fromsklearn.model_selection import train_test_split

fromsklearn.feature_extraction.text import

CountVectorizer from sklearn.neural_network

import MLPClassifier

fromsklearn.metrics import accuracy_score, confusion_matrix, precision_score, recall_score

msg = pd.read_csv('document.csv',

names=['message', 'label']) print("Total Instances of

Dataset: ", msg.shape[0]) msg['labelnum'] =

msg.label.map({'pos': 1, 'neg': 0})

X=

msg.me

ssage y

msg.lab

Elnum

Xtrain, Xtest, ytrain, ytest = train_test_split(X, y)

count_v = CountVectorizer()

Xtrain_dm =

count_v.fit_transform(Xtrain)

Xtest_dm =

count_v.transform(Xtest)

df = pd.DataFrame(Xtrain_dm.toarray(),columns=count_v.get_feature_names())
clf = MLPClassifier(solver='lbfgs', alpha=1e-5,hidden_layer_sizes=(5, 2),

random_state=1)

clf.fit(Xtrain_dm, ytrain) pred = clf.predict(Xtest_dm)

print('Accuracy Metrics:')

print('Accuracy: ', accuracy_score(ytest, pred)) print('Recall: ', recall_score(ytest, pred))

print('Precision: ', precision_score(ytest, pred))

print('Confusion Matrix: \n', confusion_matrix(ytest, pred)),

document.csv:

I love this sandwich

,pos This is

an amazingplace,

pos KG CO

I feel very good about these

beers,pos This is my best

work,pos

What an awesome view,pos

I do not like this

restaurant,neg I am

tired of this stuff,neg

I can't deal with this,neg

He is my sworn enemy,ne

My boss is horrible,neg

This is an awesome place,pos

I do not like the taste of this

juice,neg I love to dance,pos

I am sick and tired

of this place,neg

What a great holiday,pos

That is a bad locality to stay

,neg We will have good fun

tomorrow,pos I went to my

enemy's house today,neg

OUTPUT:

Total Instances of Dataset: 18

Accuracy Metrics:

Accuracy: 0.8

Recall: 1.0

Precisio n: 0.75

Confusi on Matrix:

[[1 1]

[0 3]}
VIVA QUESTIONS:

What is machine learning?

Define supervised learning?

Define unsupervised learning?

Define semi supervised learning?

Define reinforcement learning?

What do you mean by hypotheses is classification?

What is clustering?

Define precision, accuracy and recall 10.Define entropy?

Define regression?

How Knn is different from k-means clustering?

What is concept learning?

Define specific boundary and general boundary?

Define target function 16.Define decision tree?

What is ANN?

Explain gradient descent approximation?

State Bayes theorem?

Define Bayesian belief networks?

Differentiate hard and soft clustering?

Define variance 23. What is inductive machine learning?

Why K nearest neighbour algorithm is lazy learning algorithm?

Why naïve Bayes is naïve?

Mention classification algorithms?

Define pruning 28.Differentiate Clustering and classification?

Mention clustering algorithms and Define Bias?