part A

1. Write a program to describe the dataset using pandasdataframe commands and

encode the

same.

Program Code :

fromsklearn import datasets

importnumpy as np

import pandas as pd

fromsklearn.preprocessing import LabelEncoder, OneHotEncoder

data=pd.read_csv(r"C:\Users\jackw\Downloads\iris.csv")

iris=datasets.load_iris()

data=pd.DataFrame(data=np.c_[iris['data'],iris['target']],

columns=iris['feature_names']+['target'])

data['target_names']=data['target'].replace(dict(enumerate(iris.target_names)))

print(data.head())

data.info()

print(data.describe())

Label_encoder=LabelEncoder()

data['target_names']=Label_encoder.fit_transform(data['target_names'])

print(data['target_names'])

print(Label_encoder.classes_)

print(data['target_names'].value_counts())

One_hot=OneHotEncoder()

transformed_data=One_hot.fit_transform(data['target_names'].values.reshape(-1,1)
).toarray()

print(One_hot.categories_)

transformed_data=pd.DataFrame(transformed_data,
columns=['setosa','versicolor','virginica'])

print(transformed_data.head())

2. Write a program to visualize the iris dataset using sepal and petal values.

Program Code:

fromsklearn import datasets

importnumpy as np

import pandas as pd
importmatplotlib.pyplot as plt

iris = datasets.load_iris()

data = pd.DataFrame(data=iris.data, columns=iris.feature_names)

print(data)

fig, ax = plt.subplots() # Assign fig here

scatter = ax.scatter(iris.data[:, 0], iris.data[:, 1], c=iris.target)

ax.set(xlabel=iris.feature_names[0], ylabel=iris.feature_names[1])

ax.legend(scatter.legend_elements()[0], iris.target_names, loc="lower right",

title="Classes")

plt.show()

fig, ax = plt.subplots()

scatter = ax.scatter(iris.data[:, 0], iris.data[:, 1], c=iris.target)

ax.set(xlabel=iris.feature_names[2], ylabel=iris.feature_names[3])

ax.legend(scatter.legend_elements()[0], iris.target_names, loc="lower right",

title="Classes")

plt.show()

3. Write a program to apply linear regression on the iris dataset and find the
error of prediction.

Ans: from sklearn import datasets, decomposition

import pandas as pd

fromsklearn.linear_model import LinearRegression

fromsklearn.model_selection import train_test_split

fromsklearn.metrics import mean_squared_error

importmatplotlib.pyplot as plt

iris = datasets.load_iris()

X = iris.data

y = iris.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,

random_state=42)

model = LinearRegression()

model.fit(X_train, y_train)

y_pred = model.predict(X_test)

mse = mean_squared_error(y_test, y_pred)

print("Mean Squared Error:", mse)

4. Write a program to apply logistic regression on the iris dataset.

Ans: from sklearn import datasets, decomposition

import pandas as pd

fromsklearn.linear_model import LogisticRegression

fromsklearn.model_selection import train_test_split

fromsklearn.metrics import mean_squared_error

iris = datasets.load_iris()

data = pd.DataFrame(data=iris.data, columns=iris.feature_names)

X = data

y = iris.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,

random_state=42)

logreg = LogisticRegression(solver='lbfgs', penalty='l2', max_iter=10000)

logreg.fit(X_train, y_train)

y_pred = logreg.predict(X_test)

mse = mean_squared_error(y_test, y_pred)

print("Mean Squared Error:", mse)

accuracy = logreg.score(X_test, y_test)

print("Logistic regression Accuracy:", accuracy)

5. Write a program to apply naïve bayes classifier on the iris dataset.

Ans: from sklearn import datasets, decomposition

import pandas as pd

fromsklearn.model_selection import train_test_split

fromsklearn.naive_bayes import GaussianNB

fromsklearn.metrics import accuracy_score

iris = datasets.load_iris()

X = iris.data

y = iris.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,

random_state=42)

model = GaussianNB()

model.fit(X_train, y_train)

y_pred = model.predict(X_test)
accuray = accuracy_score(y_pred, y_test)

print("Accuracy score is:", accuray)

6.Write a program to apply k-means clustering on the iris dataset.

Ans: from sklearn import datasets, decomposition

import pandas as pd

fromsklearn.model_selection import train_test_split

fromsklearn.cluster import KMeans

importmatplotlib.pyplot as plt

iris = datasets.load_iris()

X = iris.data

y = iris.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,

random_state=42)

kmeans = KMeans(n_clusters = 3, init = 'k-means++', max_iter = 300, n_init = 10,

random_state = 0)

y_kmeans = kmeans.fit_predict(X)

plt.scatter(X[y_kmeans == 0, 0], X[y_kmeans == 0, 1], s = 100, c = 'purple',

label = 'Iris-setosa')

plt.scatter(X[y_kmeans == 1, 0], X[y_kmeans == 1, 1], s = 100, c = 'orange',

label = 'Iris-versicolour')

plt.scatter(X[y_kmeans == 2, 0], X[y_kmeans == 2, 1], s = 100, c = 'green',

label = 'Iris-virginica')

plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:,1], s =

100, c = 'red', label =

'Centroids')

plt.legend()

plt.show()

Part B

1. Write a program to normalize the iris dataset using standardization.

Program Code:

fromsklearn import datasets

import pandas as pd

fromsklearn.preprocessing import StandardScaler, MinMaxScaler

import warnings

iris = datasets.load_iris()

data = pd.DataFrame(data=iris.data, columns=iris.feature_names)

print(data)

print('Average of Feature')

print(data.mean())

print('\nFeature Variance')

print(data.var())

scaler = StandardScaler()

scaler.fit(data)

iris_scaled_std = scaler.transform(data)

iris_df_std_scaled = pd.DataFrame(data=iris_scaled_std,
columns=iris.feature_names)

print('Standardized Feature Average')

print(iris_df_std_scaled.mean())

print('\nStandardized Feature Variance')

print(iris_df_std_scaled.var())

scaler = MinMaxScaler()

scaler.fit(data)

iris_scaled_minmax = scaler.transform(data)

iris_df_minmax_scaled = pd.DataFrame(data=iris_scaled_minmax,
columns=iris.feature_names)

print('MinMax Scaled Feature Average')

print(iris_df_minmax_scaled.mean())

print('\nMinMax Scaled Feature Variance')

print(iris_df_minmax_scaled.var())

print('\nMinMax Scaled Min Value')

print(iris_df_minmax_scaled.min())

print('\nMinMax Scaled Max Value')

print(iris_df_minmax_scaled.max())

2. Write a program to impute the missing values and perform discrete

transformation on the iris

dataset.

Program Code:

fromsklearn import datasets

importnumpy as np

import pandas as pd
fromsklearn.preprocessing import KBinsDiscretizer

fromsklearn.impute import SimpleImputer

import warnings

iris = datasets.load_iris()

data = pd.DataFrame(data=iris.data, columns=iris.feature_names)

print(data)

imputer = SimpleImputer(missing_values=np.nan, strategy='mean')

print(imputer)

imputer = imputer.fit(data)

imputed_dataset = imputer.transform(data)

print(imputed_dataset)

iris_quantile_transform = KBinsDiscretizer(n_bins=10, encode='ordinal',

strategy='quantile')

quantile_transformed_data = iris_quantile_transform.fit_transform(data)

print(pd.DataFrame(quantile_transformed_data))

iris_uniform_transform = KBinsDiscretizer(n_bins=10, encode='ordinal',

strategy='uniform')

uniform_transformed_data = iris_uniform_transform.fit_transform(data)

print(pd.DataFrame(uniform_transformed_data))

3. Write a program to apply principal component analysis on the iris dataset.

Program Code:

fromsklearn import datasets, decomposition

importnumpy as np

import pandas as pd

importmatplotlib.pyplot as plt

import mpl_toolkits.mplot3d

iris = datasets.load_iris()

data = pd.DataFrame(data=iris.data, columns=iris.feature_names)

X = data

y = iris.target

print(data)

fig = plt.figure(1, figsize=(4, 3))

plt.clf()
ax = fig.add_subplot(111, projection="3d", elev=48, azim=134)

ax.set_position([0, 0, 0.95, 1])

plt.cla()

pca = decomposition.PCA(n_components=3)

pca.fit(X)

X = pca.transform(X)

print(X)

for name, label in [("Setosa", 0), ("Versicolour", 1), ("Virginica", 2)]:

ax.text3D(

X[y == label, 0].mean(),

X[y == label, 1].mean() + 1.5,

X[y == label, 2].mean(),

name,

horizontalalignment="center",

bbox=dict(alpha=0.5, edgecolor="w", facecolor="w"), )

y = np.choose(y, [1, 2, 0]).astype(float)

ax.scatter(X[:, 0], X[:, 1], X[:, 2], c=y, cmap=plt.cm.nipy_spectral,

edgecolor="k")
ax.xaxis.set_ticklabels([])

ax.yaxis.set_ticklabels([])

ax.zaxis.set_ticklabels([])

plt.show()

4. Write a program to apply support vector machine classifier on the iris

dataset and generate a

confusion matrix of the classifier.

Ans: from sklearn import datasets, decomposition

import pandas as pd

fromsklearn.model_selection import train_test_split

fromsklearn.svm import SVC

fromsklearn.metrics import confusion_matrix

fromsklearn.model_selection import cross_val_score

iris = datasets.load_iris()

X = iris.data
y = iris.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,

random_state=42)

SVM_classifier = SVC(kernel='linear', random_state=0)

SVM_classifier.fit(X_train, y_train)

accuracy = cross_val_score(estimator=SVM_classifier, X=X_train, y=y_train,

cv=10)

print("Accuracy: {:.2f} %".format(accuracy.mean()*100))

y_pred = SVM_classifier.predict(X_test)

SVM_cm = confusion_matrix(y_test, y_pred)

print("The confusion matrix is:")

print(SVM_cm)

5.Develop Decision Tree Classification model for a given dataset and use it to
classify a

new sample.

from sklearn import datasets

from sklearn.model_selection import train_test_split

from sklearn.tree import DecisionTreeClassifier

from sklearn.metrics import accuracy_score, confusion_matrix,

classification_report

iris = datasets.load_iris()

X = iris.data
y = iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,
random_state=42)

dt_classifier = DecisionTreeClassifier(random_state=42)

dt_classifier.fit(X_train, y_train)

y_pred = dt_classifier.predict(X_test)

accuracy = accuracy_score(y_test, y_pred)

conf_matrix = confusion_matrix(y_test, y_pred)

class_report = classification_report(y_test, y_pred)

print(f"Accuracy: {accuracy * 100:.2f}%")

print("\nConfusion Matrix:")

print(conf_matrix)

print("\nClassification Report:")

print(class_report)
new_sample = [[5.1, 3.5, 1.4, 0.2]] # Example: a new Iris sample (sepal_length,
sepal_width,

petal_length, petal_width)

new_prediction = dt_classifier.predict(new_sample)

print(f"\nPredicted class for the new sample: {iris.target_names[new_prediction]

[0]}")

6.Build KNN Classification model for a given dataset.

import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, confusion_matrix,
classification_report
iris = datasets.load_iris()
X = iris.data
y = iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,
random_state=42)
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)

conf_matrix = confusion_matrix(y_test, y_pred)

class_report = classification_report(y_test, y_pred)

print(f"Accuracy: {accuracy * 100:.2f}%")

print("\nConfusion Matrix:")

print(conf_matrix)

print("\nClassification Report:")

print(class_report)

new_sample = [[5.1, 3.5, 1.4, 0.2]]

new_prediction = knn.predict(new_sample)

print(f"\nPredicted class for the new sample: {iris.target_names[new_prediction]

[0]}")