# --- Program 1: FIND-S Algorithm ---
# Filename: find_s.py
"""
Implements the FIND-S algorithm to find the most specific hypothesis
that fits the given training data.
"""
import csv
print("Data in csv file is:")
data = []
with open("sedData.csv", "r") as fp: # Corrected file extension
read = csv.reader(fp)
for r in read:
data.append(r)
print(r)
print("\n")
n = len(data[0]) - 1
print(" No. of attributes are:", n)
print("Initial Hypothesis: ")
hypothesis = ['0'] * n
print(hypothesis)
for i in range(0, len(data)):
if (data[i][n] == 'yes'):
for j in range(0, n):
hypothesis[j] = data[i][j]
break
print(hypothesis)
print("\n")
print("After every iteration: ")
for i in range(0, len(data)):
if (data[i][n] == 'yes'):
for j in range(0, n):
if (hypothesis[j] != data[i][j]):
hypothesis[j] = '?'
print(hypothesis)
print("\n")
print("Final Hypothesis:")
print(hypothesis)
# --- Program 2: Candidate Elimination Algorithm ---
# Filename: candidate_elimination.py
"""
Implements the Candidate Elimination Algorithm to find the most general
and most specific hypotheses that are consistent with the training data.
"""
import numpy as np
import pandas as pd
data = pd.read_csv('ML2.CSV') # Corrected CSV name
concepts = np.array(data)[:, :-1]
print("Instances are:\n", concepts)
target = np.array(data)[:, -1]
def learn(concepts, target):
specific_h = concepts[0].copy()
print("\nInitialization of specific_h & general_h")
print("Specific boundary:\n", specific_h)
general_h = [["?" for i in range(len(specific_h))] for i in range(len(specific_h))]
print("General boundary:\n", general_h)
for i, h in enumerate(concepts):
print("\nInstance", i+1, "is", h)
if target[i] == "yes":
print("Instance is positive")
for x in range(len(specific_h)):
if h[x] != specific_h[x]:
specific_h[x] = '?'
general_h[x][x] = '?'
elif target[i] == "no":
print("Instance is negative")
for x in range(len(specific_h)):
if h[x] != specific_h[x]:
general_h[x][x] = specific_h[x]
else:
general_h[x][x] = '?'
print("Specific boundary after", i+1, "instance:\n", specific_h)
print("General boundary after", i+1, "instance:\n", general_h)
print("\n")
indices = [i for i, val in enumerate(general_h) if val == ['?', '?', '?', '?', '?']] #
Adjusted to 5 question marks
for i in indices:
general_h.remove(['?', '?', '?', '?', '?']) #Adjusted to 5 question marks
return specific_h, general_h
s_final, g_final = learn(concepts, target)
print("Final specific-h:\n", s_final)
print("Final general_h:\n", g_final)
# --- Program 3: Decision Tree ---
# Filename: decision_tree.py
"""
Implements a simple decision tree using scikit-learn.
"""
from sklearn.tree import DecisionTreeClassifier
import numpy as np
X = np.array([[1, 1, 1],
[1, 0, 1],
[0, 1, 0],
[0, 0, 1],
[1, 1, 0]])
y = np.array([1, 1, 0, 0, 1])
tree = DecisionTreeClassifier(criterion='entropy') # Using criterion entropy
tree.fit(X, y)
new_sample = np.array([[1, 0, 1]])
predicted_class = tree.predict(new_sample)
print("Predicted class:", predicted_class[0])
# --- Program 4: Linear Regression ---
# Filename: linear_regression.py
"""
Performs linear regression on a given dataset using scikit-learn.
"""
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt
import numpy as np
data = pd.read_csv("lab3.csv") # Changed filename to lab3.csv
print(data)
diameter = data['diameter'].values.reshape(-1, 1)
price = data['price'].values
model = LinearRegression()
model.fit(diameter, price)
intercept = model.intercept_
slope = model.coef_[0]
print("Intercept:", intercept)
print("Slope:", slope)
predictions = model.predict(diameter)
mse = np.mean((predictions - price) ** 2)
print("Mean squared Error:", mse)
plt.scatter(diameter, price, color='blue')
plt.plot(diameter, predictions, color='red')
plt.xlabel('Diameter')
plt.ylabel('Price')
plt.title("Linear Regression")
plt.show()
new_diameter = np.array([20]).reshape(-1, 1) # Corrected: Reshape the input
future_price = model.predict(new_diameter)
print("Predicted price for a diameter of 20:", future_price[0])
# --- Program 5: Logistic Regression ---
# Filename: logistic_regression.py
"""
Performs logistic regression on a given dataset using scikit-learn.
"""
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
data = pd.read_csv('labs.csv')
print(data)
X = data[['studyhours']]
y = data['examresult']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
random_state=42)
model = LogisticRegression()
model.fit(X_train, y_train)
predictions = model.predict(X_test)
accuracy = accuracy_score(y_test, predictions)
print("Accuracy:", accuracy)
new_data = pd.DataFrame({'studyhours': [1, 7, 9]})
new_predictions = model.predict(new_data)
print("New predictions:")
for i, prediction in enumerate(new_predictions):
print("Instance {}: predicted Result: {}".format(i+1, prediction))
# --- Program 6: Binary classifier (Likely another Logistic Regression example,
slightly different) ---
# Filename: binary_classifier.py
"""
Performs binary classification (using Logistic Regression) on a dataset.
"""
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
data = pd.read_csv('lab3.csv')
print(data)
X = data[['studyhours']]
Y = data['examresult'] # Corrected target variable name
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2,
random_state=42) # Corrected test_size
model = LogisticRegression()
model.fit(X_train, y_train)
predictions = model.predict(X_test)
accuracy = accuracy_score(y_test, predictions)
print("Accuracy: ", accuracy)
new_data = pd.DataFrame({'studyhours': [1, 7, 9]})
new_predictions = model.predict(new_data)
print("New predictions:")
for i, prediction in enumerate(new_predictions):
print("Instance {}: Predicted Result {}".format(i+1, prediction))
# --- Program 7: Bias, Variance, Cross-Validation ---
# Filename: bias_variance_cv.py
"""
Demonstrates how to calculate bias and variance using cross-validation
for a linear regression model.
"""
import pandas as pd
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LinearRegression, LogisticRegression #Added
Logistic Regression import
from statistics import mean, stdev
data = pd.read_csv("wineQT.csv")
X_set = data.drop('quality', axis=1) # Corrected to X_set
y_set = data['quality']
# Linear Regression
model = LinearRegression()
scores = cross_val_score(model, X_set, y_set, cv=10)
print("Linear Regression Scores:", scores)
print("Linear Regression Bias (Mean):", mean(scores))
print("Linear Regression Variance (StDev):", stdev(scores))
# K-fold Cross Validation (K-list wasn't used correctly in the images)
# Here's a correct way to show how bias and variance change with different folds
k_values = [2, 5, 10, 20] # Example values for K
bias_scores = []
variance_scores = []
for k in k_values:
model = LinearRegression() # Create new model for each K
scores = cross_val_score(model, X_set, y_set, cv=k)
bias_scores.append(mean(scores))
variance_scores.append(stdev(scores))
print("\nLinear Regression K-Fold Validation Results:")
for i in range(len(k_values)):
print(f"K={k_values[i]}: Bias={bias_scores[i]:.4f}, Variance={variance_scores[i]:.4f}")
# --- Program 8: K-Nearest Neighbors (KNN) ---
# Filename: knn.py
"""
Implements the K-Nearest Neighbors algorithm on the Iris dataset.
"""
from sklearn.datasets import load_iris
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
iris = load_iris()
X = iris.data
y = iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25,
random_state=0)
knn = KNeighborsClassifier()
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy)
print("Correct predictions:")
for i in range(len(y_test)):
if y_test[i] == y_pred[i]:
print("True label:", iris.target_names[y_test[i]], "-Predicted label:",
iris.target_names[y_pred[i]])
print("\nWrong Predictions:")
for i in range(len(y_test)):
if y_test[i] != y_pred[i]:
print("True label:", iris.target_names[y_test[i]], "-predicted label:",
iris.target_names[y_pred[i]])
# --- Program 9: Locally Weighted Regression ---
# Filename: locally_weighted_regression.py
"""
Implements Locally Weighted Regression.
"""
import numpy as np
import matplotlib.pyplot as plt
def lwr(x_train, y_train, x_test, tau):
y_pred = np.zeros(len(x_test))
for i, test_point in enumerate(x_test):
weights = np.exp(-((x_train - test_point) ** 2) / (2 * tau ** 2))
X = np.vstack([np.ones_like(x_train), x_train]).T
W = np.diag(weights)
try:
theta = np.linalg.inv(X.T @ W @ X) @ (X.T @ (W @ y_train))
y_pred[i] = np.array([1, test_point]) @ theta
except np.linalg.LinAlgError:
print("Singular matrix encountered. Adjusting tau or data may be needed.")
y_pred[i] = 0 # or some other default value
return y_pred
np.random.seed(42)
x_train = np.linspace(0, 10, 100)
y_train = 2 * np.sin(x_train) + np.random.normal(0, 0.2, 100)
x_test = np.linspace(0, 10, 50)
tau = 0.1 # Corrected tau value (0.01 was likely too small)
y_pred = lwr(x_train, y_train, x_test, tau)
plt.scatter(x_train, y_train, color='blue')
plt.plot(x_test, y_pred, color='red')
plt.title("Locally Weighted Regression")
plt.xlabel('x')
plt.ylabel('y')
plt.show()
# --- Program 10: Naive Bayes ---
# Filename: naive_bayes.py
"""
Implements Naive Bayes classification on the Iris dataset.
"""
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score, precision_score
iris = load_iris()
X, y = iris.data, iris.target
target_names = iris.target_names
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
random_state=42)
nb_classifier = GaussianNB()
nb_classifier.fit(X_train, y_train)
y_pred = nb_classifier.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred, average='weighted')
print('Accuracy:', accuracy)
print("Precision:", precision)
# predict for new values
new_data = [[5.1, 3.5, 1.4, 0.2], [6.9, 3.2, 5.7, 2.3]] # Example Data
new_prediction = nb_classifier.predict(new_data)
print("New predictions:", [target_names[prediction] for prediction in new_prediction])
# --- Program 11: EM and K-Means Clustering ---
# Filename: em_kmeans.py
"""
Compares EM (Gaussian Mixture Model) and K-Means clustering on
a heart disease dataset.
"""
import pandas as pd
from sklearn.cluster import KMeans
from sklearn.mixture import GaussianMixture
from sklearn.preprocessing import StandardScaler
import numpy as np
import matplotlib.pyplot as plt
# Load the data, handling potential errors
try:
data = pd.read_csv("heart.csv") # Make sure 'heart.csv' is in the same directory
except FileNotFoundError:
print("Error: The file 'heart.csv' was not found.")
exit()
except pd.errors.EmptyDataError:
print("Error: The file 'heart.csv' is empty.")
exit()
except pd.errors.ParserError:
print("Error: The file 'heart.csv' could not be parsed. Check the format.")
exit()
features = ['trestbps', 'chol'] # Features for clustering
X = data[features]
# Scale the data
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
# K-Means Clustering
kmeans = KMeans(n_clusters=2, random_state=42, n_init=10)
kmeans.fit(X_scaled)
kmeans_labels = kmeans.labels_
# EM Clustering (Gaussian Mixture Model)
em = GaussianMixture(n_components=2, random_state=42)
em.fit(X_scaled)
em_labels = em.predict(X_scaled)
# Create a colormap
colormap = np.array(['red', 'green'])
# Create the plot
plt.figure(figsize=(14, 5))
# Original Data
plt.subplot(1, 3, 1)
plt.scatter(X['trestbps'], X['chol'], c=colormap[data['target']], s=40)
plt.title('Original Data')
plt.xlabel('trestbps')
plt.ylabel('chol')
# K-Means Clustering
plt.subplot(1, 3, 2)
plt.scatter(X['trestbps'], X['chol'], c=colormap[kmeans_labels], s=40)
plt.title('K-Means Clustering')
plt.xlabel('trestbps')
plt.ylabel('chol')
# EM Clustering
plt.subplot(1, 3, 3)
plt.scatter(X['trestbps'], X['chol'], c=colormap[em_labels], s=40)
plt.title('EM Clustering')
plt.xlabel('trestbps')
plt.ylabel('chol')
plt.show()
# --- Program 12: Exploratory Data Analysis (EDA) ---
# Filename: exploratory_data_analysis.py
"""
Performs Exploratory Data Analysis on the Iris dataset using pandas and matplotlib.
"""
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
# Load data, with error handling
try:
df = pd.read_csv('IRIS.csv') # Change filename to IRIS.csv
except FileNotFoundError:
print("Error: The file 'IRIS.csv' was not found.")
exit()
except pd.errors.EmptyDataError:
print("Error: The file 'IRIS.csv' is empty.")
exit()
except pd.errors.ParserError:
print("Error: The file 'IRIS.csv' could not be parsed.")
exit()
print("Exploratory data analysis of iris dataset:\n")
print("First few rows:\n", df.head())
print("\nData information:\n", df.info())
print("\nMissing values:\n", df.isnull().sum())
print("\nColumn names:\n", df.columns)
print("\nValue counts for 'species':\n", df['species'].value_counts())
print("\nData types of each column:\n", df.dtypes)
print("\nCorrelation matrix:\n", df.corr(numeric_only=True)) # numeric_only added
# --- Program 13: Bayesian Network ---
# Filename: bayesian_network.py
"""
Constructs a Bayesian network for diagnosing heart disease using pgmpy.
"""
import numpy as np
import pandas as pd
from pgmpy.models import BayesianModel
from pgmpy.estimators import MaximumLikelihoodEstimator
from pgmpy.inference import VariableElimination
# Load the data, handling possible errors
try:
heartDisease = pd.read_csv('heart.csv') # Replace with correct path
except FileNotFoundError:
print("Error: The file 'heart.csv' was not found.")
exit()
except pd.errors.EmptyDataError:
print("Error: The file 'heart.csv' is empty.")
exit()
except pd.errors.ParserError:
print("Error: The file 'heart.csv' could not be parsed.")
exit()
heartDisease = heartDisease.replace('?', np.nan)
print("Few examples from dataset are:")
print(heartDisease.head())
model = BayesianModel([('age', 'trestbps'), ('age', 'fbs'), ('sex', 'trestbps'),
('exang', 'trestbps'), ('trestbps', 'heartdisease'), ('fbs', 'heartdisease'),
('heartdisease', 'restecg'), ('heartdisease', 'thalach'), ('heartdisease',
'chol')])
print("\nLearning CPD using Maximum Likelihood Estimators")
model.fit(heartDisease, estimator=MaximumLikelihoodEstimator)
print("\nInferencing with Bayesian Network!")
HeartDisease_infer = VariableElimination(model)
print("\n1. Probability of Heart Disease given age = 30:")
q = HeartDisease_infer.query(variables=['heartdisease'], evidence={'age': 30})
print(q['heartdisease'])
print("\n2. Probability of Heart Disease given cholesterol = 100:")
q = HeartDisease_infer.query(variables=['heartdisease'], evidence={'chol': 100})
print(q['heartdisease'])
# --- Program 14: Support Vector Machine (SVM) ---
# Filename: svm_classification.py
"""
Implements Support Vector Machine (SVM) classification on the Iris dataset.
"""
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score
# Load data
iris = load_iris()
X = iris.data[:, :2] # Use only the first two features for visualization
y = iris.target
# Split data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25,
random_state=0)
# Scale data
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
# Train SVM classifier
svm_classifier = SVC(kernel='linear', C=1.0, random_state=0)
svm_classifier.fit(X_train, y_train)
# Make predictions
y_pred_train = svm_classifier.predict(X_train)
y_pred_test = svm_classifier.predict(X_test)
# Calculate accuracy
accuracy_train = accuracy_score(y_train, y_pred_train)
accuracy_test = accuracy_score(y_test, y_pred_test)
print("Training accuracy:", accuracy_train)
print("Testing accuracy:", accuracy_test)
# Plot decision boundary (adapted from example)
def plot_decision_boundary(classifier, X, y):
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02),
np.arange(y_min, y_max, 0.02))
Z = classifier.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z, alpha=0.4)
plt.scatter(X[:, 0], X[:, 1], c=y, marker='o', edgecolors='k')
plt.xlabel("Feature 1")
plt.ylabel("Feature 2")
plt.title("Decision Boundary")
plt.show()
plot_decision_boundary(svm_classifier, X_train, y_train)
# --- Program 15: Principal Component Analysis (PCA) ---
# Filename: pca_analysis.py
"""
Demonstrates Principal Component Analysis (PCA) using scikit-learn.
"""
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.decomposition import PCA
# Example 1 (Simple array)
X = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
pca = PCA(n_components=2)
pca.fit(X)
X_transformed = pca.transform(X)
print("Original data:\n", X)
print("\nTransformed data:\n", X_transformed)
# Example 2 (Iris dataset)
iris = load_iris()
X = iris.data
y = iris.target
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)
plt.figure(figsize=(8, 6))
for i in range(len(iris.target_names)):
plt.scatter(X_pca[y == i, 0], X_pca[y == i, 1], label=iris.target_names[i])
plt.xlabel('Principal Component 1')
plt.ylabel('Principal Component 2')
plt.title('PCA of Iris Dataset')
plt.legend()
plt.show()
