Exp 1 page no.
1
Regression Model
Aim : To write a program for regression model using R. a)Import a data from webpage.
Algorithm :
Step 1 : Start
Step 2 : Load ggplot2 library.
Step 3 : Import Iris dataset from URL.
Step 4 : Fit linear regression: sepal_length ~ sepal_width + petal_length + petal_width.
Step 5 : Display model summary.
Step 6 : Predict sepal_length using the model.
Step 7 : Plot actual vs predicted values.
Step 8 : Stop
Source code :
library(ggplot2)
url <- "[Link]
df <- [Link](url)
model <- lm(sepal_length ~ sepal_width + petal_length + petal_width, data = df)
summary(model)
predictions <- predict(model, df)
ggplot(df, aes(x = sepal_length, y = predictions)) +
geom_point(color = 'blue') +
geom_abline(slope = 1, intercept = 0, color = 'red', linetype = "dashed") +
labs(title = "Actual vs Predicted Sepal Length", x = "Actual", y = "Predicted") +
theme_minimal( )
Page no. 2
Result:T he program has been successfully executed.
Output:
Exp 2 : Page no. 3
Logistic regression
Aim: To write a R program for logistic regression model
Algorithm:
Step 1: Start
Step 2: Load libraries: dplyr, ggplot2.
Step 3: Generate data: Create random GRE, GPA, Rank, and Admission data.
Step 4: Fit model: Logistic regression (glm) with Admission as the target.
Step 5: Predict: Calculate predicted probabilities.
Step 6: Plot: Visualize GRE vs. predicted probabilities, colored by Admission.
Source code
library(dplyr)
library(ggplot2)
[Link](123)
n <- 200
data <- [Link](
GRE = rnorm(n, mean = 320, sd = 10),
GPA = rnorm(n, mean = 3.5, sd = 0.5)
Rank = sample(1:4, n, replace = TRUE),
Admission = sample(0:1, n, replace = TRUE)
model <- glm(Admission ~ GRE + GPA + Rank, data = data, family = binomial)
summary(model)
data$Predicted_Probabilities <- predict(model, type = "response")
ggplot(data, aes(x = GRE, y = Predicted_Probabilities, color = [Link](Admission))) +
Page no. 4
geom_point() +
labs(title = "Predicted Probabilities of Admission based on GRE Score",
x = "GRE Score",
y = "Predicted Probability of Admission") +
theme_minimal()
Result: The program has been successfully executed
Output:
Exp : 3 Page no. 5
Apriori algorithm
Aim: To implement apriori algorithm in python
Algorithm:
Step 1: Start
Step 2: Input Dataset: Provide a list of transactions, where each transaction is a list of items.
Step 3: Data Preprocessing: Convert the dataset to a one-hot encoded DataFrame.
Step 4: Apply Apriori Algorithm: Use the apriori() function to find frequent itemsets with a
minimum support threshold.
Step 5: Generate Association Rules: Use association_rules() to generate rules from the
frequent itemsets, filtering based on a metric like "lift".
Step 6:Display Results: Show frequent itemsets and association rules.
Step 7:Stop
Source code:
import pandas as pd
from mlxtend.frequent_patterns import apriori, association_rules
dataset = [ ['Milk', 'Bread', 'Butter'],
['Milk', 'Bread'],
['Bread', 'Butter'],
['Milk', 'Bread', 'Butter'],
['Milk', 'Butter']]
df = [Link](dataset, columns=['Milk', 'Bread', 'Butter'])
df = [Link]().astype('int')
frequent_itemsets = apriori(df, min_support=0.6, use_colnames=True)
print(frequent_itemsets)
rules = association_rules(frequent_itemsets, metric="lift", min_threshold=1.0)
print(rules)
Page no. 6
Result: The program has been successfully executed
Output:
Exp : 4 Page no. 7
K- Nearest Neighbor Algorithm
Aim : To implement KNN algorithm in Python
Algorithm :
Step 1 : Start
Step 2 : Load the Iris dataset
Step 3 : Create a DataFrame to view the data (optional)
Step 3 : Split the data into training and testing sets
Step 4 : Initialize the KNN classifier with k = 3
Step 5 : Train the classifier on the training data
Step 6 : Predict class labels for the test data
Step 7 : Visualize the predictions using a scatter plot of the first two features
Step : Stop
Source code:
import pandas as pd
import [Link] as plt
from sklearn import datasets
from [Link] import make_blobs
from [Link] import KNeighborsClassifier
from sklearn.model_selection import train_test_split
iris = datasets.load_iris()
df=[Link]([Link],columns=iris.feature_names)
print(df)
X = iris['data']
y = iris['target']
Page no. 8
#X, y = make_blobs(n_samples = 500, n_features = 2, centers = 4,cluster_std = 1.5,
random_state = 4)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 0)
knn3 = KNeighborsClassifier(n_neighbors = 3)
[Link](X_train, y_train)
y_pred_3 = [Link](X_test)
[Link](X_test[:,0], X_test[:,1], c=y_pred_3)
[Link]("Predicted values with k=3", fontsize=20)
[Link]()
Result : The program has been successfully executed
Output :
Page no. 9
Exp 5 page no. 10
Decision Tree Algorithm
Aim : To implement decision tree in python
Algorithm :
Step 1 : Start
Step 2 : Load the Iris dataset
Step 3 : Split data into training and testing sets (70/30)
Step 4 : Train a Decision Tree classifier on the training data
Step 5 : Predict the target values for the test data
Step 6 : Calculate and print the model’s accuracy
Step 7 : Visualize the trained decision tree with feature and class names
Step 8 : Stop
Source code :
from [Link] import load_iris
from [Link] import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from [Link] import accuracy_score
iris = load_iris()
X = [Link] # Features
y = [Link] # Labels
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
clf = DecisionTreeClassifier()
[Link](X_train, y_train)
y_pred = [Link](X_test)
accuracy = accuracy_score(y_test, y_pred)
Page no. 11
print("Accuracy:", accuracy)
from [Link] import plot_tree
import [Link] as plt
[Link](figsize=(12, 8))
plot_tree(clf, feature_names=iris.feature_names, class_names=iris.target_names, filled=True)
[Link]()
Result : The program has been successfully executed
Output :
Exp : 6 Page no. 12
K Means Algorithm
Aim :To implement K means algorithm in python
Algorithm :
Step 1 : start
Step 2 : Load the Iris dataset
Step 3 : Set the number of clusters (k = 3)
Step 4 : Apply K-Means algorithm to fit the data
Step 5 : Assign each data point to a cluster
Step 6 : Print the cluster centers
Step 7 : Plot the data points colored by cluster labels using the first two features
Step 8 : Stop
Source code :
from [Link] import load_iris
from [Link] import KMeans
import [Link] as plt
iris = load_iris()
X = [Link]
kmeans = KMeans(n_clusters=3, random_state=42)
[Link](X)
labels = kmeans.labels_
print("Cluster centers:")
print(kmeans.cluster_centers_)
[Link](X[:, 0], X[:, 1], c=labels, cmap='viridis')
[Link]("K-Means Clustering (Iris Dataset)")
Page no. 13
[Link]("Feature 1")
[Link]("Feature 2")
[Link]()
Result : The program has been successfully executed.
Output :
Exp 7 : Page no. 14
K-Medoids Algorithm
Aim : To implement K-Medoids algorithm in python.
Algorithm :
Step 1 : start
Step 2 : Load the Iris dataset
Step 3 : Initialize k random medoids from the data
Step 4 : Assign each data point to the nearest medoid (using Euclidean distance)
Step 5 : Update each medoid to the most central point (minimize total distance in its cluster)
Step 6 : Repeat steps 3–4 until medoids do not change or max iterations reached
Step 7 : Plot the final clusters and medoids using the first two features
Step 8 : Stop
Source code :
import numpy as np
import random
from [Link] import load_iris
import [Link] as plt
iris = load_iris()
X = [Link]
def euclidean_distance(a, b):
return [Link](a - b)
def assign_points(X, medoids):
clusters = {}
for idx, medoid in enumerate(medoids):
clusters[idx] = []
Page no.15
for point in X:
distances = [euclidean_distance(point, medoid) for medoid in medoids]
cluster_idx = [Link](distances)
clusters[cluster_idx].append(point)
return clusters
def calculate_cost(clusters, medoids):
cost = 0
for idx, cluster_points in [Link]():
for point in cluster_points:
cost += euclidean_distance(point, medoids[idx])
return cost
def update_medoids(clusters):
new_medoids = []
for cluster_points in [Link]():
min_cost = float('inf')
best_medoid = None
for candidate in cluster_points:
cost = sum(euclidean_distance(candidate, point) for point in cluster_points)
if cost < min_cost:
min_cost = cost
best_medoid = candidate
new_medoids.append(best_medoid)
return new_medoids
def k_medoids(X, k, max_iter=100):
Page no. 16
initial_medoids = [Link](list(X), k)
medoids = initial_medoids
for i in range(max_iter):
clusters = assign_points(X, medoids)
new_medoids = update_medoids(clusters)
if [Link]([np.array_equal(m, nm) for m, nm in zip(medoids, new_medoids)]):
break
medoids = new_medoids
return medoids, clusters
k=3
medoids, clusters = k_medoids(X, k)
colors = ['r', 'g', 'b']
for idx, points in [Link]():
points = [Link](points)
[Link](points[:, 0], points[:, 1], c=colors[idx], label=f'Cluster {idx}')
[Link](medoids[idx][0], medoids[idx][1], c='black', marker='X', s=200)
[Link]("K-Medoids Clustering (from scratch)")
[Link]("Feature 1")
[Link]("Feature 2")
[Link]()
[Link]()
Result : The program has been successfully executed.
Page no. 18
Output :
Exp 8 Page no. 19
Classification Model
Aim : To implement classification model using R
Algorithm :
Step 1 : Start
Step 2 : Load required packages (caret, e1071)
Step 3 : Import Iris dataset from the web
Step 4 : Convert species to a factor
Step 5 : Split data into training (70%) and testing (30%) sets
Step 6 : Train a k-NN model using train() from caret
Step 7 : Predict on the test data
Step 8 : Convert predictions to factor with correct levels
Step 9 : Evaluate using confusionMatrix()
Step 10 : Display accuracy and metrics
Step 11 : stop
Source code :
# Install required packages (run once if not already installed)
[Link]("caret")
[Link]("e1071")
# Load the libraries
library(caret)
library(e1071)
# Import the Iris dataset from the web
url <- "[Link]
iris_data <- [Link](url)
Page no. 20
# Convert the target column to factor (important!)
iris_data$species <- [Link](iris_data$species)
# Set seed for reproducibility
[Link](123)
# Split the data into training (70%) and testing (30%)
trainIndex <- createDataPartition(iris_data$species, p = 0.7, list = FALSE)
trainData <- iris_data[trainIndex, ]
testData <- iris_data[-trainIndex, ]
# Train a k-NN classifier using caret
knn_model <- train(species ~ ., data = trainData, method = "knn", tuneLength = 5)
# View model details
print(knn_model)
# Predict on test data
predictions <- predict(knn_model, newdata = testData)
# Make sure predictions and actual values are factors with the same levels
predictions <- factor(predictions, levels = levels(testData$species))
# Evaluate model performance
conf_matrix <- confusionMatrix(predictions, testData$species)
print(conf_matrix)
Result : The program has been executed successfully
Page no. 21
Output :
Exp : 9 Page no. 22
Correalation and Covariance Analysis
Aim : To implement correlation and covariance analysis using R
Algorithm :
Step 1 : Start
Step 2 : Load libraries and iris dataset
Step 3 : Compute correlation matrix (numeric columns only)
Step 4 : Plot the correlation matrix using corrplot
Step 5 : Perform ANOVA: [Link] ~ Species
Step 6 : Visualize ANOVA result with a boxplot
Step 7 : Stop
Source code :
library(ggplot2)
library(corrplot)
library(dplyr)
# Load the iris dataset
data(iris)
# We'll exclude the Species column since it's categorical
cor_matrix <- cor(iris[, 1:4]) # Only numerical columns
print("Correlation Matrix:")
print(cor_matrix)
### b. Plot the correlation plot
corrplot(cor_matrix, method = "color", type = "upper",
[Link] = "black", [Link] = 45, [Link] = "black",
title = "Correlation Plot of Iris Dataset", mar=c(0,0,1,0))
Page no. 23
### c. Analysis of Covariance: Variance (ANOVA)
# We'll check if species has a significant effect on [Link]
# Fit the ANOVA model
anova_model <- aov([Link] ~ Species, data = iris)
summary(anova_model)
# Plotting boxplot for visual understanding
ggplot(iris, aes(x = Species, y = [Link], fill = Species)) +
geom_boxplot() +
labs(title = "ANOVA: Sepal Length by Species",
x = "Species", y = "Sepal Length") +
theme_minimal()
Result : The program has been successfully executed
Output :
Page no. 24