1.
import pandas as pd import numpy as np import seaborn as
sns
import [Link] as plt
from [Link] import fetch_california_housing
data = fetch_california_housing(as_frame=True)
housing_df = [Link]
numerical_features =
housing_df.select_dtypes(include=[[Link]]).columns
[Link](figsize=(15, 10))
for i, feature in enumerate(numerical_features): [Link](3, 3, i
+ 1)
[Link](housing_df[feature], kde=True, bins=30, color='blue')
[Link](f'Distribution of {feature}')
plt.tight_layout() [Link]()
[Link](figsize=(15, 10))
for i, feature in enumerate(numerical_features):
[Link](3, 3, i + 1)
[Link](x=housing_df[feature], color='orange')
[Link](f'Box Plot of {feature}')
plt.tight_layout()
[Link]()
print("Outliers Detection:") outliers_summary = {}
for feature in numerical_features:
Q1 = housing_df[feature].quantile(0.25)
Q3 = housing_df[feature].quantile(0.75)
IQR = Q3 - Q1
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR
outliers = housing_df[(housing_df[feature] < lower_bound) |
(housing_df[feature] > upper_bound)]
outliers_summary[feature] = len(outliers)
print(f"{feature}: {len(outliers)} outliers")
print("\nDataset Summary:")
print(housing_df.describe())
2. import pandas as pd
import seaborn as sns
import [Link] as plt
from [Link] import fetch_california_housing
california_data = fetch_california_housing(as_frame=True) data =
california_data.frame
correlation_matrix = [Link]([Link](figsize=(10, 8))
[Link](correlation_matrix, annot=True, cmap='coolwarm',
fmt='.2f', linewidths=0.5) [Link]('Correlation Matrix of California
Housing Features')
[Link]()
[Link](data, diag_kind='kde', plot_kws={'alpha': 0.5})
[Link]('Pair Plot of California Housing Features', y=1.02)
[Link]()
3. import numpy as np
import pandas as pd
from [Link] import load_iris
from [Link] import PCA import [Link]
as plt
# Load the Iris
dataset iris = load_iris()
data = [Link]
labels = [Link]
label_names = iris.target_names
# Convert to a DataFrame for better visualization
iris_df = [Link](data, columns=iris.feature_names)
# Perform PCA to reduce dimensionality to 2
pca = PCA(n_components=2)
data_reduced = pca.fit_transform(data)
# Create a DataFrame for the reduced data
reduced_df = [Link](data_reduced, columns=['Principal
Component 1', 'Principal Component 2'])reduced_df['Label'] =
labels
# Plot the reduced data [Link](figsize=(8, 6)) colors = ['r', 'g',
'b']
for i, label in enumerate([Link](labels)):
[Link](
reduced_df[reduced_df['Label'] == label]['Principal Component
1'], reduced_df[reduced_df['Label'] == label]['Principal
Component 2'], label=label_names[label],
color=colors[i]
)
[Link]('PCA on Iris Dataset')
[Link]('Principal Component 1')
[Link]('Principal Component 2')
[Link]()
[Link]()
[Link]()
4. import pandas as pd
import numpy as np
data = pd.read_csv("[Link]")
print(data,"n")
d = [Link](data)[:,:-1]
print("n The attributes are: ",d) target = [Link](data)[:,-1]
print("n The target is: ",target) def train(c,t)
for i, val in enumerate(t):
if val == "Yes":
specific_hypothesis =
c[i].copy() break
for i, val in enumerate
if t[i] == "Yes":
for x in range(len(specific_hypothesis)):
if val[x] != specific_hypothesis[x]:
specific_hypothesis[x] = '?'
else:
pass
return specific_hypothesis
print("n The final hypothesis is:",train(d,target))
5. import numpy as np
import [Link] as pltfrom collections
import Counter data = [Link](100)
labels = ["Class1" if x <= 0.5 else "Class2" for x in data[:50]] def
euclidean_distance(x1, x2):
return abs(x1 - x2)
def knn_classifier(train_data, train_labels, test_point, k):
distances = [(euclidean_distance(test_point, train_data[i]),
train_labels[i]) for i in range(len(train_data))]
[Link](key=lambda x: x[0])
k_nearest_neighbors = distances[:k]
k_nearest_labels = [label for _, label in k_nearest_neighbors]
return Counter(k_nearest_labels).most_common(1)[0][0]
train_data = data[:50]
train_labels = labels
test_data = data[50:]
k_values = [1, 2, 3, 4, 5, 20, 30]
print("--- k-Nearest Neighbors Classification ---")
print("Training dataset: First 50 points labeled based on the rule
(x <= 0.5 -> Class1, x > 0.5 -
> Class2)")
print("Testing dataset: Remaining 50 points to be classified\n")
results = {}
for k in k_values:
print(f"Results for k = {k}:")
classified_labels = [knn_classifier(train_data, train_labels,
test_point, k) for test_point in test_data]
results[k] = classified_labels
for i, label in enumerate(classified_labels, start=51):
print(f"Point x{i} (value: {test_data[i - 51]:.4f}) is classified as
{label}")
print("\n")
print("Classification complete.\n") for k in k_values:
classified_labels = results[k]
class1_points = [test_data[i] for i in range(len(test_data)) if
classified_labels[i] == "Class1"]
class2_points = [test_data[i] for i in range(len(test_data)) if
classified_labels[i] == "Class2"]
[Link](figsize=(10, 6))
[Link](train_data, [0] * len(train_data), c=["blue" if label ==
"Class1" else "red" for label in train_labels],
label="Training Data", marker="o")
[Link](class1_points, [1] * len(class1_points), c="blue",
label="Class1 (Test)", marker="x")
[Link](class2_points, [1] * len(class2_points), c="red",
label="Class2 (Test)", marker="x")
[Link](f"k-NN Classification Results for k = {k}")
[Link]("Data Points")
[Link]("Classification Level")
[Link]()
[Link](True)
[Link]()
6. import numpy as np
import [Link] as plt
def gaussian_kernel(x, xi, tau):
return [Link](-[Link]((x - xi) ** 2) / (2 * tau ** 2))
def locally_weighted_regression(x, X, y, tau):m = [Link][0]
weights = [Link]([gaussian_kernel(x, X[i], tau)
for i in range(m)]) W = [Link](weights)
X_transpose_W = X.T @ W
theta = [Link](X_transpose_W @ X) @ X_transpose_W @
y return x @ theta
[Link](42)
X = [Link](0, 2 * [Link], 100)
y = [Link](X) + 0.1 * [Link](100)
X_bias = np.c_[[Link]([Link]), X]
x_test = [Link](0, 2 * [Link], 200)
x_test_bias = np.c_[[Link](x_test.shape), x_test] tau = 0.5
y_pred = [Link]([locally_weighted_regression(xi, X_bias, y, tau)
for xi in x_test_bias]) [Link](figsize=(10, 6))
[Link](X, y, color='red', label='Training Data', alpha=0.7)
[Link](x_test, y_pred, color='blue', label=f'LWR Fit (tau={tau})',
linewidth=2)
[Link]('X', fontsize=12)
[Link]('y', fontsize=12)
[Link]('Locally Weighted Regression', fontsize=14)
[Link](fontsize=10)
[Link](alpha=0.3)
[Link]()
7. import numpy as np
import pandas as pd
import [Link] as plt
from [Link] import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from [Link] import PolynomialFeatures,
StandardScaler
from [Link] import make_pipeline
from [Link] import mean_squared_error, r2_score
def linear_regression_california():
housing = fetch_california_housing(as_frame=True)
X = [Link][["AveRooms"]]
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)
[Link](X_test, y_test, color="blue", label="Actual")
[Link](X_test, y_pred, color="red", label="Predicted")
[Link]("Average number of rooms (AveRooms)")
[Link]("Median value of homes ($100,000)")
[Link]("Linear Regression - California Housing Dataset")
[Link]()
[Link]()
print("Linear Regression - California Housing Dataset")
print("Mean Squared Error:", mean_squared_error(y_test,
y_pred))
print("R^2 Score:", r2_score(y_test, y_pred))
def polynomial_regression_auto_mpg():
url = "[Link]
databases/auto-mpg/[Link]"
column_names = ["mpg", "cylinders", "displacement",
"horsepower", "weight", "acceleration", "model_year", "origin"]
data = pd.read_csv(url, sep='\s+', names=column_names,
na_values="?")
data = [Link]()
X = data["displacement"].[Link](-1, 1)
y = data["mpg"].values
X_train, X_test, y_train, y_test = train_test_split(X, y,
test_size=0.2, random_state=42)
poly_model = make_pipeline(PolynomialFeatures(degree=2),
StandardScaler(), LinearRegression())
poly_model.fit(X_train, y_train)
y_pred = poly_model.predict(X_test)
[Link](X_test, y_test, color="blue", label="Actual")
[Link](X_test, y_pred, color="red", label="Predicted")
[Link]("Displacement")
[Link]("Miles per gallon (mpg)")
[Link]("Polynomial Regression - Auto MPG Dataset")
[Link]()
[Link]()
print("Polynomial Regression - Auto MPG Dataset")
print("Mean Squared Error:", mean_squared_error(y_test,
y_pred))
print("R^2 Score:", r2_score(y_test, y_pred))
if __name__ == "__main__":
print("Demonstrating Linear Regression and Polynomial
Regression\n")
linear_regression_california()
polynomial_regression_auto_mpg()
8. import numpy as np
import [Link] as plt
from [Link] import load_breast_cancer
from sklearn.model_selection import train_test_split
from [Link] import DecisionTreeClassifier
from [Link] import accuracy_score
from sklearn import tree
data = load_breast_cancer()
X = [Link] y = [Link]
X_train, X_test, y_train, y_test = train_test_split(X, y,
test_size=0.2, random_state=42)
clf = DecisionTreeClassifier(random_state=42)
[Link](X_train, y_train) y_pred = [Link](X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Model Accuracy: {accuracy * 100:.2f}%")
new_sample = [Link]([X_test[0]])
prediction = [Link](new_sample)
prediction_class = "Benign" if prediction == 1 else "Malignant"
print(f"Predicted Class for the new sample: {prediction_class}")
[Link](figsize=(12,8))
tree.plot_tree(clf, filled=True,
feature_names=data.feature_names,
class_names=data.target_names)
[Link]("Decision Tree - Breast Cancer Dataset")
[Link]()
9. import numpy as np
from [Link] import fetch_olivetti_faces
from sklearn.model_selection import train_test_split,
cross_val_score
from sklearn.naive_bayes import GaussianNB
from [Link] import accuracy_score, classification_report,
confusion_matrix
import [Link] as plt
data = fetch_olivetti_faces(shuffle=True, random_state=42)
X = [Link] y = [Link]
X_train, X_test, y_train, y_test = train_test_split(X, y,
test_size=0.3, random_state=42)
gnb = GaussianNB()
[Link](X_train, y_train)
y_pred = [Link](X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy * 100:.2f}%')
print("\nClassification Report:")
print(classification_report(y_test, y_pred, zero_division=1))
print("\nConfusion Matrix:")
print(confusion_matrix(y_test, y_pred))
cross_val_accuracy = cross_val_score(gnb, X, y, cv=5,
scoring='accuracy')
print(f'\nCross-validation accuracy: {cross_val_accuracy.mean() *
100:.2f}%')
fig, axes = [Link](3, 5, figsize=(12, 8))
for ax, image, label, prediction in zip([Link](), X_test, y_test,
y_pred): [Link]([Link](64, 64), cmap=[Link])
ax.set_title(f"True: {label}, Pred: {prediction}")
[Link]('off')
[Link]()
10.. import numpy as np
import [Link] as plt
import seaborn as sns
from [Link] import load_breast_cancer
from [Link] import KMeans
from [Link] import PCA
from [Link] import StandardScaler
data = load_breast_cancer() X = [Link] # Features
scaler = StandardScaler() X_scaled = scaler.fit_transform(X)
kmeans = KMeans(n_clusters=2, random_state=42, n_init=10)
clusters = kmeans.fit_predict(X_scaled)
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)
centroids_original = kmeans.cluster_centers_ centroids_pca =
[Link](centroids_original) # Convert centroids to 2D
[Link](figsize=(8, 6))
for cluster, color in zip(range(2), ["red", "blue"]):
[Link](X_pca[clusters == cluster, 0], X_pca[clusters ==
cluster, 1],
color=color, alpha=0.6, edgecolor="k", label=f"Cluster {cluster}")
[Link](centroids_pca[:, 0], centroids_pca[:, 1], s=250,
c='black', marker='X', label="Centroids"
[Link](loc="upper right")
[Link]("K-Means Clustering on Wisconsin Breast Cancer
Dataset") [Link]("Principal Component 1")
[Link]("Principal Component 2")
[Link]()