1.

prgm

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import fetch_california_housing

# Load dataset
df = pd.DataFrame(fetch_california_housing().data,
columns=fetch_california_housing().feature_names)
df['Target'] = fetch_california_housing().target

# Histograms
df.hist(figsize=(12, 10), bins=30, edgecolor='black')
plt.suptitle('Histograms')
plt.tight_layout()
plt.subplots_adjust(top=0.9)
plt.show()

# Box Plots
plt.figure(figsize=(12, 10))
sns.boxplot(data=df, orient='h', palette='Set2')
plt.title('Box Plots')
plt.show()

2. prgm

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_california_housing

# Load the dataset

df = pd.DataFrame(fetch_california_housing().data,
columns=fetch_california_housing().feature_names)
df['target'] = fetch_california_housing().target

# Correlation matrix heatmap

sns.heatmap(df.corr(), annot=True, cmap='coolwarm', fmt='.2f')
plt.title('Correlation Matrix')
plt.show()

# Pair plot
sns.pairplot(df)
plt.suptitle('Pairwise Relationships', y=1.02)
plt.show()

3.pgrm

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler

# Load and standardize the Iris dataset

X = load_iris().data
X_scaled = StandardScaler().fit_transform(X)

# Compute the covariance matrix and perform eigendecomposition

cov_matrix = np.cov(X_scaled.T)
eigenvalues, eigenvectors = np.linalg.eig(cov_matrix)

# Project data onto the top 2 principal components

X_pca = X_scaled.dot(eigenvectors[:, :2])

# Plot the results

plt.scatter(X_pca[:, 0], X_pca[:, 1], c=load_iris().target, cmap='viridis')
plt.xlabel('PC 1')
plt.ylabel('PC 2')
plt.title('PCA of Iris Dataset')
plt.colorbar(label='Target Class')
plt.show()

4. pgrm

import csv

h=['0'for i in range(6)]
with open("C:\\Users\\SKSVMACET\\Desktop\\kl.csv") as f:
data=csv.reader(f)
data=list(data)

for i in data:
 if i[-1]=="Yes":
for j in range(6):
if h[j]=='0':
h[j]=i[j]
elif h[j]!=i[j]:
h[j]='?'

print(h)

5. prgm

import numpy as np
from sklearn.neighbors import KNeighborsClassifier
import matplotlib.pyplot as plt

# Generate 100 random points between 0 and 1

X = np.random.rand(100, 1)
y = np.array([1 if x <= 0.5 else 2 for x in X[:50]])

# Classify remaining points (X[50:] with unknown labels)

X_new = X[50:]

# k-NN classification for different k values

k_values = [1, 2, 3, 4, 5, 20, 30]
plt.figure(figsize=(10, 8))

for i, k in enumerate(k_values, 1):

knn = KNeighborsClassifier(n_neighbors=k)
knn.fit(X[:50], y)
y_pred = knn.predict(X_new)

plt.subplot(3, 3, i)
plt.scatter(X[:50], y, c=y, marker='o')
plt.scatter(X_new, y_pred, c=y_pred, marker='x')
plt.title(f'k={k}')
plt.xlabel('x')
plt.ylabel('Class')

plt.tight_layout()
plt.show()
6. prgm

import numpy as np
import matplotlib.pyplot as plt

# Generate synthetic data

X = np.sort(np.random.rand(100, 1), axis=0)
y = np.sin(2 * np.pi * X).ravel() + 0.1 * np.random.randn(100)

# Perform Locally Weighted Regression

def lwr(X, y, query_points, tau=0.1):
predictions = []
for x in query_points:
W = np.diag([np.exp(-np.linalg.norm(x - xi) ** 2 / (2 * tau ** 2)) for xi in X])
X_bias = np.hstack((np.ones((len(X), 1)), X))
theta = np.linalg.pinv(X_bias.T @ W @ X_bias) @ (X_bias.T @ W @ y)
predictions.append(np.hstack(([1], x)) @ theta)
return predictions

# Visualize data and LWR result

query_points = np.linspace(0, 1, 100).reshape(-1, 1)
predictions = lwr(X, y, query_points)

plt.scatter(X, y, color='blue')
plt.plot(query_points, predictions, color='red', lw=2)
plt.title('Locally Weighted Regression')
plt.xlabel('X')
plt.ylabel('y')
plt.show()

7. prgm

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import make_pipeline
from sklearn.metrics import mean_squared_error, r2_score

def linear_regression_california():
housing = fetch_california_housing()
X, y = housing.data[:, 3].reshape(-1, 1), housing.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = LinearRegression().fit(X_train, y_train)
y_pred = model.predict(X_test)

plt.scatter(X_test, y_test, color="blue")

plt.plot(X_test, y_pred, color="red")
plt.xlabel("AveRooms")
plt.ylabel("House Price ($100K)")
plt.show()
print("MSE:", mean_squared_error(y_test, y_pred), "R2:", r2_score(y_test, y_pred))

def polynomial_regression_auto_mpg():
url = "https://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data"
data = pd.read_csv(url, sep='\s+', names=["mpg", "cylinders", "displacement", "horsepower",
"weight", "acceleration", "model_year", "origin"], na_values="?").dropna()
X, y = data["displacement"].values.reshape(-1, 1), data["mpg"].values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = make_pipeline(PolynomialFeatures(degree=2), LinearRegression()).fit(X_train,
y_train)
y_pred = model.predict(X_test)

plt.scatter(X_test, y_test, color="blue")

plt.scatter(X_test, y_pred, color="red")
plt.xlabel("Displacement")
plt.ylabel("MPG")
plt.show()
print("MSE:", mean_squared_error(y_test, y_pred), "R2:", r2_score(y_test, y_pred))

if __name__ == "__main__":
linear_regression_california()
polynomial_regression_auto_mpg()

8. prgm
# Import necessary libraries
import numpy as np
import pandas as pd
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

# Step 1: Load the Breast Cancer dataset

data = load_breast_cancer()
X = data.data # Features
y = data.target # Labels (0 for malignant, 1 for benign)

# Step 2: Split the dataset into training and testing sets (80% train, 20% test)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Step 3: Create and train the Decision Tree classifier

clf = DecisionTreeClassifier(random_state=42)
clf.fit(X_train, y_train)

# Step 4: Evaluate the model on the test data

y_pred = clf.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy of the Decision Tree classifier: {accuracy:.2f}")

# Step 5: Classify a new sample (using an example sample from the dataset)
# Let's use the first sample from the test set as an example for prediction
sample = X_test[0].reshape(1, -1) # Reshaping the sample to 2D for prediction

# Predicting the class of the new sample

predicted_class = clf.predict(sample)
class_names = data.target_names

# Output the predicted class for the sample

print(f"The new sample is classified as: {class_names[predicted_class[0]]}")

9. prgm

import numpy as np
from sklearn.datasets import fetch_olivetti_faces
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
import matplotlib.pyplot as plt

# Load the Olivetti Faces dataset

data = fetch_olivetti_faces(shuffle=True, random_state=42)
X = data.data
y = data.target

# Split the dataset into training and test sets

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

# Initialize the Gaussian Naive Bayes classifier

gnb = GaussianNB()

# Train the classifier

gnb.fit(X_train, y_train)

# Make predictions on the test set

y_pred = gnb.predict(X_test)

# Calculate the accuracy

accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy * 100:.2f}%')

# Print the classification report (without zero_division argument)

print("\nClassification Report:")
print(classification_report(y_test, y_pred))

# Print the confusion matrix

print("\nConfusion Matrix:")
print(confusion_matrix(y_test, y_pred))

# Cross-validation accuracy
cross_val_accuracy = cross_val_score(gnb, X, y, cv=5, scoring='accuracy')
print(f'\nCross-validation accuracy: {cross_val_accuracy.mean() * 100:.2f}%')

# Plotting some sample images from the test set

fig, axes = plt.subplots(3, 5, figsize=(12, 8))
for ax, image, label, prediction in zip(axes.ravel(), X_test, y_test, y_pred):
ax.imshow(image.reshape(64, 64), cmap=plt.cm.gray)
ax.set_title(f"True: {label}, Pred: {prediction}")
 ax.axis('off')

plt.show()

10. prgm

import matplotlib.pyplot as plt

from sklearn.datasets import load_breast_cancer
from sklearn.cluster import KMeans
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler

# Load and preprocess data

X = load_breast_cancer().data
X = StandardScaler().fit_transform(X)

# Apply KMeans clustering

y_kmeans = KMeans(n_clusters=2, random_state=42).fit_predict(X)

# PCA for 2D visualization

X_pca = PCA(n_components=2).fit_transform(X)

# Plot the clustering result

plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y_kmeans, cmap='viridis', s=50, alpha=0.6)
plt.title('K-Means Clustering on Breast Cancer Dataset')
plt.xlabel('PC 1')
plt.ylabel('PC 2')
plt.show()