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
[Link] import LabelEncoder, OneHotEncoder
data=pd.read_csv(r"C:\Users\jackw\Downloads\[Link]")
iris=datasets.load_iris()
data=[Link](data=np.c_[iris['data'],iris['target']],
columns=iris['feature_names']+['target'])
data['target_names']=data['target'].replace(dict(enumerate(iris.target_names)))
print([Link]())
[Link]()
print([Link]())
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'].[Link](-1,1)
).toarray()
print(One_hot.categories_)
transformed_data=[Link](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
[Link] as plt
iris = datasets.load_iris()
data = [Link](data=[Link], columns=iris.feature_names)
print(data)
fig, ax = [Link]() # Assign fig here
scatter = [Link]([Link][:, 0], [Link][:, 1], c=[Link])
[Link](xlabel=iris.feature_names[0], ylabel=iris.feature_names[1])
[Link](scatter.legend_elements()[0], iris.target_names, loc="lower right",
title="Classes")
[Link]()
fig, ax = [Link]()
scatter = [Link]([Link][:, 0], [Link][:, 1], c=[Link])
[Link](xlabel=iris.feature_names[2], ylabel=iris.feature_names[3])
[Link](scatter.legend_elements()[0], iris.target_names, loc="lower right",
title="Classes")
[Link]()
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
[Link] import mean_squared_error
[Link] as plt
iris = datasets.load_iris()
X = [Link]
y = [Link]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
random_state=42)
model = LinearRegression()
[Link](X_train, y_train)
y_pred = [Link](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
[Link] import mean_squared_error
iris = datasets.load_iris()
data = [Link](data=[Link], columns=iris.feature_names)
X = data
y = [Link]
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)
[Link](X_train, y_train)
y_pred = [Link](X_test)
mse = mean_squared_error(y_test, y_pred)
print("Mean Squared Error:", mse)
accuracy = [Link](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
[Link] import accuracy_score
iris = datasets.load_iris()
X = [Link]
y = [Link]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,
random_state=42)
model = GaussianNB()
[Link](X_train, y_train)
y_pred = [Link](X_test)
accuray = accuracy_score(y_pred, y_test)
print("Accuracy score is:", accuray)
[Link] 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
[Link] import KMeans
[Link] as plt
iris = datasets.load_iris()
X = [Link]
y = [Link]
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)
[Link](X[y_kmeans == 0, 0], X[y_kmeans == 0, 1], s = 100, c = 'purple',
label = 'Iris-setosa')
[Link](X[y_kmeans == 1, 0], X[y_kmeans == 1, 1], s = 100, c = 'orange',
label = 'Iris-versicolour')
[Link](X[y_kmeans == 2, 0], X[y_kmeans == 2, 1], s = 100, c = 'green',
label = 'Iris-virginica')
[Link](kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:,1], s =
100, c = 'red', label =
'Centroids')
[Link]()
[Link]()
Part B
1. Write a program to normalize the iris dataset using standardization.
Program Code:
fromsklearn import datasets
import pandas as pd
[Link] import StandardScaler, MinMaxScaler
import warnings
iris = datasets.load_iris()
data = [Link](data=[Link], columns=iris.feature_names)
print(data)
print('Average of Feature')
print([Link]())
print('\nFeature Variance')
print([Link]())
scaler = StandardScaler()
[Link](data)
iris_scaled_std = [Link](data)
iris_df_std_scaled = [Link](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()
[Link](data)
iris_scaled_minmax = [Link](data)
iris_df_minmax_scaled = [Link](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
[Link] import KBinsDiscretizer
[Link] import SimpleImputer
import warnings
iris = datasets.load_iris()
data = [Link](data=[Link], columns=iris.feature_names)
print(data)
imputer = SimpleImputer(missing_values=[Link], strategy='mean')
print(imputer)
imputer = [Link](data)
imputed_dataset = [Link](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([Link](quantile_transformed_data))
iris_uniform_transform = KBinsDiscretizer(n_bins=10, encode='ordinal',
strategy='uniform')
uniform_transformed_data = iris_uniform_transform.fit_transform(data)
print([Link](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
[Link] as plt
import mpl_toolkits.mplot3d
iris = datasets.load_iris()
data = [Link](data=[Link], columns=iris.feature_names)
X = data
y = [Link]
print(data)
fig = [Link](1, figsize=(4, 3))
[Link]()
ax = fig.add_subplot(111, projection="3d", elev=48, azim=134)
ax.set_position([0, 0, 0.95, 1])
[Link]()
pca = [Link](n_components=3)
[Link](X)
X = [Link](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 = [Link](y, [1, 2, 0]).astype(float)
[Link](X[:, 0], X[:, 1], X[:, 2], c=y, cmap=[Link].nipy_spectral,
edgecolor="k")
[Link].set_ticklabels([])
[Link].set_ticklabels([])
[Link].set_ticklabels([])
[Link]()
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
[Link] import SVC
[Link] import confusion_matrix
fromsklearn.model_selection import cross_val_score
iris = datasets.load_iris()
X = [Link]
y = [Link]
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([Link]()*100))
y_pred = SVM_classifier.predict(X_test)
SVM_cm = confusion_matrix(y_test, y_pred)
print("The confusion matrix is:")
print(SVM_cm)
[Link] 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 [Link] import DecisionTreeClassifier
from [Link] import accuracy_score, confusion_matrix,
classification_report
iris = datasets.load_iris()
X = [Link]
y = [Link]
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]}")
[Link] KNN Classification model for a given dataset.
import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split
from [Link] import StandardScaler
from [Link] import KNeighborsClassifier
from [Link] import accuracy_score, confusion_matrix,
classification_report
iris = datasets.load_iris()
X = [Link]
y = [Link]
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 = [Link](X_test)
knn = KNeighborsClassifier(n_neighbors=3)
[Link](X_train, y_train)
y_pred = [Link](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 = [Link](new_sample)
print(f"\nPredicted class for the new sample: {iris.target_names[new_prediction]
[0]}")