unit2
December 25, 2023
3)Implement the Euclidean distance and Cosine similarity metrics from scratch in Python and
apply them to compare two vectors or data points.
[ ]: import math
# Function to calculate Euclidean distance
def euclidean_distance(vector1, vector2):
if len(vector1) != len(vector2):
raise ValueError("Both vectors must have the same dimensions.")
return math.sqrt(sum((x - y) ** 2 for x, y in zip(vector1, vector2))))
# Function to calculate Cosine similarity
def cosine_similarity(vector1, vector2):
if len(vector1) != len(vector2):
raise ValueError("Both vectors must have the same dimensions.")
dot_product = sum(x * y for x, y in zip(vector1, vector2))
magnitude_vector1 = math.sqrt(sum(x ** 2 for x in vector1))
magnitude_vector2 = math.sqrt(sum(x ** 2 for x in vector2))
return dot_product / (magnitude_vector1 * magnitude_vector2)
# Define two vectors
vector1 = [3, 1, 4, 1, 5]
vector2 = [2, 1, 2, 2, 3]
# Calculate Euclidean distance between vector1 and vector2
print("Euclidean distance: ", euclidean_distance(vector1, vector2))
# Calculate Cosine similarity between vector1 and vector2
print("Cosine similarity: ", cosine_similarity(vector1, vector2))
7)Implement the KNN algorithm in Python and apply it to a dataset to make predictions for a
new data point.
[ ]: import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsRegressor
from sklearn.metrics import mean_squared_error
import matplotlib.pyplot as plt
1
# Generate a synthetic dataset
np.random.seed(42)
X = np.sort(5 * np.random.rand(100, 1), axis=0)
y = np.sin(X).ravel()
# Split the dataset into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,␣
↪random_state=42)
# Visualize the dataset
plt.scatter(X, y, color='blue', label='Original Data')
plt.title('Synthetic Dataset for KNN Regression')
plt.xlabel('X')
plt.ylabel('y')
plt.legend()
plt.show()
# Implement KNN Regression
knn_regressor = KNeighborsRegressor(n_neighbors=3) # You can adjust the number␣
↪of neighbors (k)
knn_regressor.fit(X_train, y_train)
# Make predictions for a new data point
new_data_point = np.array([[2.5]]) # Replace with your own data point
predicted_value = knn_regressor.predict(new_data_point)
# Visualize the regression line
X_range = np.linspace(0, 5, 100).reshape(-1, 1)
y_pred_range = knn_regressor.predict(X_range)
plt.scatter(X, y, color='blue', label='Original Data')
plt.plot(X_range, y_pred_range, color='red', label='KNN Regression Line')
plt.scatter(new_data_point, predicted_value, color='green', label='New Data␣
↪Point Prediction', marker='x', s=100)
plt.title('KNN Regression')
plt.xlabel('X')
plt.ylabel('y')
plt.legend()
plt.show()
# Evaluate the model on the test set
y_pred_test = knn_regressor.predict(X_test)
mse = mean_squared_error(y_test, y_pred_test)
print(f'Mean Squared Error on Test Set: {mse:.2f}')
9)Train a logistic regression model on a binary classification dataset and analyze the importance
2
of each feature using their corresponding coefficients.
[ ]: import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
# Load the Iris dataset
iris = load_iris()
X = iris.data
y = iris.target
# Considering two classes for binary classification
X_binary = X[y != 2]
y_binary = y[y != 2]
# Split the dataset into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X_binary, y_binary,␣
↪test_size=0.2, random_state=42)
# Train a logistic regression model
logreg_model = LogisticRegression()
logreg_model.fit(X_train, y_train)
# Make predictions on the test set
y_pred = logreg_model.predict(X_test)
# Evaluate the model
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy on Test Set: {accuracy:.2f}')
# Analyze feature importance using coefficients
feature_importance = pd.DataFrame({
'Feature': iris.feature_names,
'Coefficient': logreg_model.coef_[0]
})
# Display the feature importance
print('\nFeature Importance:')
print(feature_importance)
11)Implement a linear SVM classifier using Python’s scikit-learn library for a binary classification
problem. Visualize the decision boundary and support vectors.
[ ]: import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
3
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
# Load a synthetic dataset for binary classification
X, y = datasets.make_classification(n_samples=100, n_features=2, n_classes=2,␣
↪n_clusters_per_class=1, random_state=42)
# Split the dataset into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,␣
↪random_state=42)
# Train a linear SVM classifier
svm_classifier = SVC(kernel='linear')
svm_classifier.fit(X_train, y_train)
# Visualize the decision boundary and support vectors
plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap='viridis',␣
↪marker='o', label='Training Data')
plt.scatter(svm_classifier.support_vectors_[:, 0], svm_classifier.
↪support_vectors_[:, 1],
s=100, facecolors='none', edgecolors='k', marker='o',␣
↪label='Support Vectors')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
# Create a meshgrid to plot the decision boundary
xx, yy = np.meshgrid(np.linspace(X[:, 0].min(), X[:, 0].max(), 100),
np.linspace(X[:, 1].min(), X[:, 1].max(), 100))
Z = svm_classifier.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
# Plot decision boundary
plt.contour(xx, yy, Z, colors='k', levels=[-1, 0, 1], alpha=0.5,␣
↪linestyles=['--', '-', '--'])
plt.title('Linear SVM Classifier with Decision Boundary and Support Vectors')
plt.legend()
plt.show()
13)Build a Naive Bayes classifier to classify text documents into different categories. Preprocess
the text data and use the Laplace smoothing technique to handle unseen words.
[ ]: import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import accuracy_score, classification_report
4
# Sample text data for illustration
data = {'text': ["This is a positive document.",
"Negative sentiment detected in this text.",
"The sentiment in this document is positive.",
"This is another positive example."],
'label': ['Positive', 'Negative', 'Positive', 'Positive']}
df = pd.DataFrame(data)
# Split the dataset into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(df['text'], df['label'],␣
↪test_size=0.2, random_state=42)
# Preprocess the text data using CountVectorizer
vectorizer = CountVectorizer()
X_train_vectorized = vectorizer.fit_transform(X_train)
X_test_vectorized = vectorizer.transform(X_test)
# Build a Naive Bayes classifier with Laplace smoothing
naive_bayes_classifier = MultinomialNB(alpha=1.0) # Laplace smoothing␣
↪parameter (alpha=1.0 for add-one smoothing)
naive_bayes_classifier.fit(X_train_vectorized, y_train)
# Make predictions on the test set
y_pred = naive_bayes_classifier.predict(X_test_vectorized)
# Evaluate the classifier
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy:.2f}\n')
print('Classification Report:')
print(classification_report(y_test, y_pred))
# Test with a new document
new_document = ["This document is very positive and contains positive words."]
new_document_vectorized = vectorizer.transform(new_document)
predicted_category = naive_bayes_classifier.predict(new_document_vectorized)
print(f'\nPredicted Category for the New Document: {predicted_category[0]}')
14)Compare the performance of the Naive Bayes algorithm with other classification algorithms on
a given dataset.
[ ]: import numpy as np
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
5
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score, classification_report
# Load the Iris dataset
iris = load_iris()
X = iris.data
y = iris.target
# Split the dataset into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,␣
↪random_state=42)
# Standardize the features
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
# Define classifiers
classifiers = {
'Naive Bayes': GaussianNB(),
'Random Forest': RandomForestClassifier(random_state=42),
'Support Vector Machine': SVC(kernel='linear', random_state=42),
'K-Nearest Neighbors': KNeighborsClassifier(),
}
# Train and evaluate each classifier
results = []
for clf_name, clf in classifiers.items():
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
classification_rep = classification_report(y_test, y_pred,␣
↪target_names=iris.target_names, output_dict=True)
results.append({'Classifier': clf_name, 'Accuracy': accuracy,␣
↪'Classification Report': classification_rep})
# Display the results
df_results = pd.DataFrame(results)
print(df_results)
15) Build a Random Forest classifier using scikit-learn and apply it to a dataset
6
[ ]: import numpy as np
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report
# Load the Iris dataset
iris = load_iris()
X = iris.data
y = iris.target
# Split the dataset into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,␣
↪random_state=42)
# Build a Random Forest classifier
random_forest_classifier = RandomForestClassifier(n_estimators=100,␣
↪random_state=42)
random_forest_classifier.fit(X_train, y_train)
# Make predictions on the test set
y_pred = random_forest_classifier.predict(X_test)
# Evaluate the classifier
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy:.2f}\n')
print('Classification Report:')
print(classification_report(y_test, y_pred, target_names=iris.target_names))
