S V ENGINEERING COLLEGE

(Formerly S V Engineering College for Women)

Karakambadi Road, Tirupati - 517 507
Permanent Affiliation to JNTUA & Approved by AICTE
Recognized under section 2(f) & 12(B) of UGC act 1956.
Accredited by NAAC

DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING(AI & ML)

LAB MANUAL

PYTHON PROGRAMMING & DATA SCIENCE LAB

Regulation – 20
Academic Year (2020 – 21)
Year / Semester: I / II
 VISION OF THE INSTITUTE

To emerge as a Centre of Excellence with superior academic standards while

imparting quality education to develop contemporary innovative practices and
systems to become technologically empowered and ethically strong for the
betterment of the society.

MISSION OF THE INSTITUTE

 M1 : To create excellent infrastructure facilities and state-of-

the-art laboratories and incubation centers.

 M2 : To implement modern pedagogical methods in delivering

the academic programs with experienced and committed
faculty

 M3 : To develop a good rapport with the industries and

exchange information on latest technological
development, provide training for the faculty, staff and
students.

 M4 : To enhance leadership qualities among the youth and

enrich personality traits, promote patriotism and moral
values.

 M5 : To inculcate ethical values and environmental

consciousness through holistic education programs

VISION OF THE DEPARTMENT

To become a center of excellence that grooms globally competent and ethical

engineers with the talent for higher learning and research and the capability to
think critically of innovative solutions for diverse social needs.
 MISSION OF THE DEPARTMENT

 M1:To impart quality technical education with strong foundations using

superior academic standards and well-equipped infrastructure.
 M2: To provide excellent pedagogies through qualified and highly skilled
faculty who are trained on a regular basis.
 M3:To establish research labs and a center of excellence that will nurture
the technical skills by training them with state of art technology required for
the industry.
 M4:To inculcate professional and ethical values in the students along with
leadership qualities so that they are well equipped to handle the dynamic
and diverse challenges they will face as engineers.

Program Educational Objectives

The program educational objectives of the Computer Science and Engineering

program describe accomplishments that graduates are expected to attain after 3
to 5 years of graduation.

 PEO1:To exhibit strong fundamental concepts of Computer Science &

Engineering along with advanced knowledge on emerging technologies so that
they can devise solutions for real time & social issues.
 PEO2:To be employed, to pursue higher studies, to become entrepreneurs
and also to have an excellent aptitude for research.
 PEO3:To be technically sound, socially acceptable and ethical professionals
with global competence.
 PEO4:To be young leaders with the capability to lead teams with good
communication skills and excellence in social awareness.

Program Specific Outcomes

 PSO1:An ability to get an employment in Computer Science and Engineering
field and related software industries.
 PSO2:An ability to participate in competitive examinations and enable them
to pursue higher education.

Program Outcomes

 PO1:Engineering knowledge: Apply knowledge of mathematics, science,

engineering fundamentals, and an engineering specialization for the solution
of complex engineering problems.
 PO2:Problem analysis: Identify, formulate, research literature, and
analyses complex engineering problems reaching substantiated conclusions
using first principles of mathematics, natural sciences, and engineering
sciences.
 PO3:Design/development of solutions: Design solutions for complex
engineering problems and design system components or processes that meet
the specified needs with appropriate consideration for public health and
safety, and cultural, societal, and environmental considerations.
 PO4:Conduct investigations of complex problems: Use research-based
knowledge and research methods including design of experiments, analysis
and interpretation of data, and synthesis of the information to provide valid
conclusions.
 PO5:Modern tool usage: Create, select, and apply appropriate techniques,
resources, and modern engineering and IT tools including prediction and
modeling to complex engineering activities with an understanding of the
limitations.
 PO6:The engineer and society: Apply reasoning informed by the contextual
knowledge to assess societal, health, safety, legal, and cultural issues and the
consequent responsibilities relevant to the professional engineering practice.
 PO7:Environment and sustainability: Understand the impact of the
professional engineering solutions in societal and environmental contexts, and
demonstrate the knowledge of, and need for sustainable development.
 PO8:Ethics:Apply ethical principles and commit to professional ethics and
responsibilities and norms of the engineering practice.
 PO9:Individual and team work: Function effectively as an individual, and
as a member or leader in diverse teams, and in multidisciplinary settings.
 PO10:Communication: Communicate effectively on complex engineering
activities with the engineering community and with the society at large, such
as being able to comprehend and write effective reports and design
documentation, make effective presentations, and give and receive clear
instructions
 PO11:Project management and finance: Demonstrate knowledge and
understanding of the engineering and management principles and apply these
to one’s own work, as a member and leader in a team, to manage projects
and in multidisciplinary environments.
 PO12:Life-long learning: Recognize the need for, and have the preparation
and ability to engage in independent and life-long learning in the broadest
context of technological change.
 INDEX

S.NO NAME OF THE PROGRAM PAGE –

NUMBERS
1 Write a program to demonstrate a) Different numeric data types and b) To perform
different
Arithmetic Operations on numbers in Python.
2
Write a program to create, append, and remove lists in Python.
3 Write a program to demonstrate working with tuples in Python.

4 Write a program to demonstrate working with dictionaries in Python

5 Write a program to demonstrate a) arrays b) array indexing such as slicing, integer

array indexing and Boolean array indexing along with their basic operations in
NumPy.
6 Write a program to compute summary statistics such as mean, median, mode,
standard deviation and variance of the given different types of data.
7 Write a script named copyfile.py. This script should prompt the user for the names
of two text files. The contents of the first file should be the input that to be written
to the second file.
8 Write a program to demonstrate Regression analysis with residual plots on a given
data set.
9 Write a program to demonstrate the working of the decision tree-based ID3
algorithm. Use an appropriate data set for building the decision tree and apply this
knowledge to classify a new sample.
10 Write a program to implement the Naïve Bayesian classifier for a sample training
data set stored as a .CSV file. Compute the accuracy of the classifier, considering
few test data sets.
11 Write a program to implement k-Nearest Neighbour algorithm to classify the iris
data set. Print both correct and wrong predictions using Java/Python ML library
classes.
12 Write a program to implement k-Means clustering algorithm to cluster the set of
data stored in.CSV file. Compare the results of various “k” values for the quality of
clustering.
13 Write a program to build Artificial Neural Network and test the same using
appropriate data sets.
 JAWAHARLAL NEHRU TECHNOLOGICAL UNIVERSITY ANANTAPUR

B. Tech I-II Sem. (CSE(AI & ML)) L T P C

0 0 3 1.5

19A05304-PYTHON PROGRAMMING LABORATORY

Course Objectives:

To train the students in solving computational problems

To elucidate solving mathematical problems using Python programming language
To understand the fundamentals of Python programming concepts and its applications.
Practical understanding of building different types of models and their evaluation.

Course out comes:

At the end of the course, the student will be able to

Illustrate the use of various data structures. (L3)

Analyze and manipulate Data using Pandas (L4)

Creating static, animated, and interactive visualizations using Matplotlib. (L6)

Understand the implementation procedures for the machine learning algorithms. (L2)

Apply appropriate data sets to the Machine Learning algorithms (L3)

Identify and apply Machine Learning algorithms to solve real-world problems (L1)
1. Write a program to demonstrate a) Different numeric data types and b) To perform different
Arithmetic Operations on numbers in Python.

2. Write a program to create, append, and remove lists in Python.

3. Write a program to demonstrate working with tuples in Python.

4. Write a program to demonstrate working with dictionaries in Python.

5. Write a program to demonstrate a) arrays b) array indexing such as slicing, integer array
indexing and Boolean array indexing along with their basic operations in NumPy.

6. Write a program to compute summary statistics such as mean, median, mode, standard
deviation and variance of the given different types of data.

7. Write a script named copyfile.py. This script should prompt the user for the names of two text
files. The contents of the first file should be the input that to be written to the second file.

8. Write a program to demonstrate Regression analysis with residual plots on a given data set.

9. Write a program to demonstrate the working of the decision tree-based ID3 algorithm. Use an
appropriate data set for building the decision tree and apply this knowledge to classify a new
sample.

10. Write a program to implement the Naïve Bayesian classifier for a sample training data set
stored as a .CSV file. Compute the accuracy of the classifier, considering few test data sets.

11. Write a program to implement k-Nearest Neighbour algorithm to classify the iris data set. Print
both correct and wrong predictions using Java/Python ML library classes.

12. Write a program to implement k-Means clustering algorithm to cluster the set of data stored in
.CSV file. Compare the results of various “k” values for the quality of clustering.

13. Write a program to build Artificial Neural Network and test the same using appropriate data
sets.
 EXPERIMENT-1

Write a program to demonstrate a) Different numeric data types and b) To perform different
Arithmetic Operations on numbers in Python

a) Different numeric data types

a=5
print("Type of a: ", type(a))
b = 5.0
print("\nType of b: ", type(b))
c = 2 + 4j
print("\nType of c: ", type(c))
String1 = "Welcome to Python Programming"
print("Initial String: ")
print(String1)
# Printing First character
print("\nFirst character of String is: ")
print(String1[0])
# Printing Last character
print("\nLast character of String is: ")
print(String1[-1])

b) To perform different Arithmetic Operations on numbers in Python

# Store input numbers:
num1 = input('Enter first number: ')
num2 = input('Enter second number: ')
# Add two numbers
sum = float(num1) + float(num2)
# Subtract two numbers
min = float(num1) - float(num2)
# Multiply two numbers
mul = float(num1) * float(num2)
#Divide two numbers

Python programming & Data science Lab 1 Dept. of CSE(AI&ML), SVEC

 div = float(num1) / float(num2)
# Display the sum
print('The sum of {0} and {1} is {2}'.format(num1, num2, sum))
# Display the subtraction
print('The subtraction of {0} and {1} is {2}'.format(num1, num2, min))
# Display the multiplication
print('The multiplication of {0} and {1} is {2}'.format(num1, num2, mul))
# Display the division
print('The division of {0} and {1} is {2}'.format(num1, num2, div))

EXPERIMENT-2

Write a program to create, append, and remove lists in Python.

# Creating a List
List = []
print("Blank List: ")
print(List)
# Creating a List of numbers
List = [10, 20, 14]
print("\nList of numbers: ")
print(List)
# Creating a List of strings and accessing
# using index
List = ["Python",”Programming”]
print("\nList Items: ")
print(List[0])
print(List[2])
List = []
print("Initial blank List: ")
print(List)
# Addition of Elements

Python programming & Data science Lab 2 Dept. of CSE(AI&ML), SVEC

# in the List
List.append(1)
List.append(2)
List.append(4)
print("\nList after Addition of Three elements: ")
print(List)
# Adding elements to the List
# using Iterator
for i in range(1, 4):
List.append(i)
print("\nList after Addition of elements from 1-3: ")
print(List)
# Adding Tuples to the List
List.append((5, 6))
print("\nList after Addition of a Tuple: ")
print(List)
# Creating a List
List = [1, 2, 3, 4, 5, 6,
7, 8, 9, 10, 11, 12]
print("Initial List: ")
print(List)
# Removing elements from List
# using Remove() method
List.remove(5)
List.remove(6)
print("\nList after Removal of two elements: ")
print(List)
# Removing elements from List
# using iterator method
for i in range(1, 5):
List.remove(i)
print("\nList after Removing a range of elements: ")

Python programming & Data science Lab 3 Dept. of CSE(AI&ML), SVEC

print(List)

EXPERIMENT – 3

Write a program to demonstrate working with tuples in Python

my_tuple = ()

print(my_tuple)

# Tuple having integers

my_tuple = (1, 2, 3)

print(my_tuple)

# tuple with mixed datatypes

my_tuple = (1, "Hello", 3.4)

print(my_tuple)

# nested tuple

my_tuple = ("mouse", [8, 4, 6], (1, 2, 3))

print(my_tuple)

# Accessing tuple elements using indexing

my_tuple = ('p','e','r','m','i','t')

print(my_tuple[0]) # 'p'

print(my_tuple[5]) # 't'

# nested tuple

n_tuple = ("mouse", [8, 4, 6], (1, 2, 3))

# nested index

print(n_tuple[0][3]) # 's'

Python programming & Data science Lab 4 Dept. of CSE(AI&ML), SVEC

print(n_tuple[1][1]) #4

EXPERIMENT-4

Write a program to demonstrate working with dictionaries in Python.

# empty dictionary

my_dict = {}

# dictionary with integer keys

my_dict = {1: 'apple', 2: 'ball'}

# dictionary with mixed keys

my_dict = {'name': 'John', 1: [2, 4, 3]}

# using dict()

my_dict = dict({1:'apple', 2:'ball'})

# from sequence having each item as a pair

my_dict = dict([(1,'apple'), (2,'ball')])

# get vs [] for retrieving elements

my_dict = {'name': 'Jack', 'age': 26}

# Output: Jack

print(my_dict['name'])

# Output: 26

print(my_dict.get('age'))

Python programming & Data science Lab 5 Dept. of CSE(AI&ML), SVEC

 # Trying to access keys which doesn't exist throws error

# Output None

print(my_dict.get('address'))

# KeyError

print(my_dict['address'])

EXPERIMENT – 5

Write a program to demonstrate a) arrays b) array indexing such as slicing, integer array indexing
and Boolean array indexing along with their basic operations in NumPy.

# Python program to demonstrate the use of NumPy arrays

import numpy as np

list1 = [1, 2, 3, 4, 5, 6]

list2 = [10, 9, 8, 7, 6, 5]

# Convert list1 into a NumPy array

a1 = np.array(list1)

# Convert list2 into a NumPy array

a2 = np.array(list2)

print(a1*a2)

import numpy as np

# Create a sequence of integers from 10 to 1 with a step of -2

a = np.arrange(10, 1, -2)

print("\n A sequential array with a negative step: \n",a)

# Indexes are specified inside the np.array method.

Python programming & Data science Lab 6 Dept. of CSE(AI&ML), SVEC

newarr = a[np.array([3, 1, 2 ])]

print("\n Elements at these indices are:\n",newarr)

# Python program for basic slicing.

import numpy as np

# Arrange elements from 0 to 19

a = np.arrange(20)

print("\n Array is:\n ",a)

# a[start:stop:step]

print("\n a[-8:17:1] = ",a[-8:17:1])

# The : operator means all elements till the end.

print("\n a[10:] = ",a[10:])

EXPERIMENT-6

Write a program to compute summary statistics such as mean, median, mode, standard deviation

and variance of the given different types of data.

import pandas as pd
import numpy as np
import statistics as st
# Load the data
df = pd.read_csv("data_desc.csv")
print(df.shape)
print(df.info())
print(df.loc[:,'Age'].mean())
print(df.loc[:,'Income'].mean())
df.mean(axis = 1)[0:5]

Python programming & Data science Lab 7 Dept. of CSE(AI&ML), SVEC

df.median()
print(df.loc[:,'Age'].median())
print(df.loc[:,'Income'].median())
df.median(axis = 1)[0:5]
df.mode()
df.std()
print(df.loc[:,'Age'].std())
print(df.loc[:,'Income'].std())
#calculate the standard deviation of the first five rows
df.std(axis = 1)[0:5]
df.var()
EXPERIMENT-7

Write a script named copyfile.py. This script should prompt the user for the names of two text files. The
contents of the first file should be the input that to be written to the second file.

# to prompt the user to enter the file1 which is input file

infile=input("enter the input filename with extension ");

# to prompt the user to enter the file2 which is output file

outfile=input("enter the output filename with extension ");

#opening the file1 in reading mode

f1=open(infile,"r");

#opening the file2 in output mode

f2=open(outfile,"w+");

#reading the content of file1 to content variable

content=f1.read();

#writing to the value of content variable to file2

f2.write(content);

#closing the file1 and file2

f1.close();
f2.close();

Python programming & Data science Lab 8 Dept. of CSE(AI&ML), SVEC

 EXPERIMENT-8

Write a program to demonstrate Regression analysis with residual plots on a given data set.
import numpy as np
import matplotlib.pyplot as plt
def estimate_coef(x, y):
# number of observations/points
n = np.size(x)
# mean of x and y vector
m_x = np.mean(x)
m_y = np.mean(y)
# calculating cross-deviation and deviation about x
SS_xy = np.sum(y*x) - n*m_y*m_x
SS_xx = np.sum(x*x) - n*m_x*m_x
# calculating regression coefficients
b_1 = SS_xy / SS_xx
b_0 = m_y - b_1*m_x
return (b_0, b_1)
def plot_regression_line(x, y, b):
# plotting the actual points as scatter plot
plt.scatter(x, y, color = "m",marker = "o", s = 30)
# predicted response vector
y_pred = b[0] + b[1]*x
# plotting the regression line
plt.plot(x, y_pred, color = "g")

# putting labels
plt.xlabel('x')
plt.ylabel('y')
# function to show plot
plt.show()
def main():
# observations / data
x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
y = np.array([1, 3, 2, 5, 7, 8, 8, 9, 10, 12])

Python programming & Data science Lab 9 Dept. of CSE(AI&ML), SVEC

 # estimating coefficients
b = estimate_coef(x, y)
print("Estimated coefficients:\nb_0 = {} \\nb_1 = {}".format(b[0], b[1]))
# plotting regression line
plot_regression_line(x, y, b)
if __name__ == "__main__":
main()

EXPERIMENT-9

Write a program to demonstrate the working of the decision tree-based ID3 algorithm.
# Importing the required packages
import numpy as np
import pandas as pd
from sklearn.metrics import confusion_matrix
from sklearn.cross_validation import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
from sklearn.metrics import classification_report
# Function importing Dataset
def importdata():
balance_data = pd.read_csv(
'https://archive.ics.uci.edu/ml/machine-learning-'+
'databases/balance-scale/balance-scale.data',
sep= ',', header = None)
# Printing the dataswet shape
print ("Dataset Length: ", len(balance_data))
print ("Dataset Shape: ", balance_data.shape)
# Printing the dataset obseravtions
print ("Dataset: ",balance_data.head())
return balance_data

Python programming & Data science Lab 10 Dept. of CSE(AI&ML), SVEC

 # Function to split the dataset
def splitdataset(balance_data):
# Separating the target variable
X = balance_data.values[:, 1:5]
Y = balance_data.values[:, 0]

# Splitting the dataset into train and test

X_train, X_test, y_train, y_test = train_test_split(
X, Y, test_size = 0.3, random_state = 100)
return X, Y, X_train, X_test, y_train, y_test
# Function to perform training with giniIndex.
def train_using_gini(X_train, X_test, y_train):
# Creating the classifier object
clf_gini = DecisionTreeClassifier(criterion = "gini",
random_state = 100,max_depth=3, min_samples_leaf=5)
# Performing training
clf_gini.fit(X_train, y_train)
return clf_gini
# Function to perform training with entropy.
def tarin_using_entropy(X_train, X_test, y_train):
# Decision tree with entropy
clf_entropy = DecisionTreeClassifier(
criterion = "entropy", random_state = 100,
max_depth = 3, min_samples_leaf = 5)
# Performing training
clf_entropy.fit(X_train, y_train)
return clf_entropy
# Function to make predictions
def prediction(X_test, clf_object):
# Predicton on test with giniIndex
y_pred = clf_object.predict(X_test)
print("Predicted values:")

Python programming & Data science Lab 11 Dept. of CSE(AI&ML), SVEC

 print(y_pred)
return y_pred
# Function to calculate accuracy
def cal_accuracy(y_test, y_pred):
print("Confusion Matrix: ",
confusion_matrix(y_test, y_pred))
print ("Accuracy : ", accuracy_score(y_test,y_pred)*100)
print("Report : ",classification_report(y_test, y_pred))
# Driver code
def main():
# Building Phase
data = importdata()
X, Y, X_train, X_test, y_train, y_test = splitdataset(data)
clf_gini = train_using_gini(X_train, X_test, y_train)
clf_entropy = tarin_using_entropy(X_train, X_test, y_train)
# Operational Phase
print("Results Using Gini Index:")
# Prediction using gini
y_pred_gini = prediction(X_test, clf_gini)
cal_accuracy(y_test, y_pred_gini)
print("Results Using Entropy:")
# Prediction using entropy
y_pred_entropy = prediction(X_test, clf_entropy)
cal_accuracy(y_test, y_pred_entropy)
# Calling main function
if __name__=="__main__":
main()

Python programming & Data science Lab 12 Dept. of CSE(AI&ML), SVEC

 EXPERIMENT-10

Write a program to implement the Naïve Bayesian classifier for a sample training data set stored as

a .CSV file.

class NaiveBayesClassifier:
def __init__(self, X, y):
'''X and y denotes the features and the target labels respectively'''
self.X, self.y = X, y
self.N = len(self.X) # Length of the training set
self.dim = len(self.X[0]) # Dimension of the vector of features
self.attrs = [[] for _ in range(self.dim)] # Here we'll store the columns of the training set
self.output_dom = {} # Output classes with the number of ocurrences in the training set. In this case
we have only 2 classes
self.data = [] # To store every row [Xi, yi]
for i in range(len(self.X)):
for j in range(self.dim):
# if we have never seen this value for this attr before,
# then we add it to the attrs array in the corresponding position
if not self.X[i][j] in self.attrs[j]:
self.attrs[j].append(self.X[i][j])
# if we have never seen this output class before,
# then we add it to the output_dom and count one occurrence for now
if not self.y[i] in self.output_dom.keys():
self.output_dom[self.y[i]] = 1
# otherwise, we increment the occurrence of this output in the training set by 1
else:
self.output_dom[self.y[i]] += 1
# store the row
self.data.append([self.X[i], self.y[i]])
def classify(self, entry):
solve = None # Final result
max_arg = -1 # partial maximum
for y in self.output_dom.keys():

Python programming & Data science Lab 13 Dept. of CSE(AI&ML), SVEC

prob = self.output_dom[y]/self.N # P(y)
for i in range(self.dim):
cases = [x for x in self.data if x[0][i] == entry[i] and x[1] == y] # all rows with Xi = xi
n = len(cases)
prob *= n/self.N # P *= P(Xi = xi)
# if we have a greater prob for this output than the partial maximum...
if prob > max_arg:
max_arg = prob
solve = y

EXPERIMENT-11

Write a program to implement k-Nearest Neighbour algorithm to classify the iris data set.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif'] = ['SimHei']
# Data generation
train_num = 200
test_num = 100
config = {
'Corn': [[150, 190], [40, 70], [2,4]],
'Potato': [[30, 60], [7, 10], [1, 2]],
'grass': [[10, 40], [10, 40], [0, 1]]
}
plants = list(config.keys())
dataset = pd.DataFrame(columns=['height(cm)', 'Leaf length(cm)', 'Stem diameter(cm)',
'type'])
index = 0
# Natural
for p in config:
for i in range(int(train_num/3-3)):
row = []

Python programming & Data science Lab 14 Dept. of CSE(AI&ML), SVEC

 for j, [min_val, max_val] in enumerate(config[p]):
v = round(np.random.rand()*(max_val-min_val)+min_val, 2)
while v in dataset[dataset.columns[j]]:
v = round(np.random.rand()*(max_val-min_val)+min_val, 2)
row.append(v)
row.append(p)
dataset.loc[index] = row
index += 1
# Wrong data
for i in range(train_num - index):
k = np.random.randint(3)
p = plants[k]
row = []
for j, [min_val, max_val] in enumerate(config[p]):
v = round(np.random.rand()*(max_val-min_val)+min_val, 2)
while v in dataset[dataset.columns[j]]:
v = round(np.random.rand()*(max_val-min_val)+min_val, 2)
row.append(v)
row.append(plants[(k+1)%3])
dataset.loc[index] = row
index+=1
# dataset = dataset.infer_objects()
dataset = dataset.reindex(np.random.permutation(len(dataset)))
dataset.reset_index(drop=True, inplace=True)
dataset.iloc[:int(train_num), :-1].to_csv('potato_train_data.csv', index=False)
dataset.iloc[:int(train_num):, [-1]].to_csv('potato_train_label.csv', index=False)

Python programming & Data science Lab 15 Dept. of CSE(AI&ML), SVEC

Here, only the training data set is generated, and the test data is similar to
this

Data visualization

We can see the distribution of data points by drawing a scatter diagram of the

data of two dimensions.

def visualize(dataset, labels, features, classes, fig_size=(10, 10), layout=None):

plt.figure(figsize=fig_size)
index = 1
if layout == None:
layout = [len(features), 1]
for i in range(len(features)):
for j in range(i+1, len(features)):
p = plt.subplot(layout[0], layout[1], index)
plt.subplots_adjust(hspace=0.4)
p.set_title(features[i]+'&'+features[j])
p.set_xlabel(features[i])
p.set_ylabel(features[j])
for k in range(len(classes)):
p.scatter(dataset[labels==k, i], dataset[labels==k, j], label=classes[k])
p.legend()
index += 1
plt.show()

dataset = pd.read_csv('potato_train_data.csv')
labels = pd.read_csv('potato_train_label.csv')
features = list(dataset.keys())
classes = np.array(['Corn', 'Potato', 'grass'])
for i in range(3):
labels.loc[labels['type']==classes[i], 'type'] = i

Python programming & Data science Lab 16 Dept. of CSE(AI&ML), SVEC

dataset = dataset.values
labels = labels['type'].values
visualize(dataset, labels, features, classes)

EXPERIMENT-12

Write a program to implement k-Means clustering algorithm to cluster the set of data stored in
.CSV file.

from sklearn.cluster import KMeans

import pandas as pd
import numpy as np
import pickle

# read csv input file

input_data = pd.read_csv("input_data.txt", sep="\t")

# initialize KMeans object specifying the number of desired clusters

kmeans = KMeans(n_clusters=4)

# learning the clustering from the input date

kmeans.fit(input_data.values)
# output the labels for the input data
print(kmeans.labels_)

# predict the classification for given data sample

predicted_class = kmeans.predict([[1, 10, 15]])
print(predicted_class)

Python programming & Data science Lab 17 Dept. of CSE(AI&ML), SVEC