NAME OF THE EXPERIMENT PAGE
NO
1 python program to compute Central Tendency
Measures :Mean, Median, Mode Measures of
Dispersion: variance ,standard Deviation
2 .Study of Python Basic Libraries such as Statistics,
Math, Numpy and Scipy
3 Study of Python Libraries for ML application such
as Pandas and Matplotlib
4 Python Program for Simple Linear Regression.
5 Implementation of Multiple Linear Regression for
House Pricing Pricing Prediction using sklearn
6 Implementation of Decision tree using sklearn and
its parameter tuning
7 Implementation of KNN using sklearn
8 Implementation of Logistic Regression using
sklearn
9 Implementation of K-Means Clustering
import numpy as np
10 Performance analysis of Classification Algorithms
1
Program 1: python program to compute Central Tendency
Measures :Mean, Median, Mode Measures of Dispersion:
variance ,standard Deviation
import statistics as stats
def central_tendency_dispersion(data):
# Central Tendency Measures
mean = stats.mean(data)
median = stats.median(data)
try:
mode = stats.mode(data)
except stats.StatisticsError:
mode = "No unique mode found"
# Measures of Dispersion
variance = stats.variance(data)
std_dev = stats.stdev(data)
# Display results
print(f"Mean: {mean}")
print(f"Median: {median}")
print(f"Mode: {mode}")
print(f"Variance: {variance}")
print(f"Standard Deviation: {std_dev}")
# Example data
2
data = [10, 15, 14, 10, 15, 18, 20, 25, 30]
central_tendency_dispersion(data)
OUTPUT:
Mean: 17.444444444444443
Median: 15
Mode: 10
Variance: 44.52777777777778
Standard Deviation: 6.672913739722534
3
2.Study of Python Basic Libraries such as Statistics, Math, Numpy and
Scipy
Python provides a wide range of basic libraries that are essential for various computational
tasks. These libraries offer functionality to handle statistical calculations, mathematical
operations, and scientific computing. Here is an overview:
Statistics Module
Used for statistical computations such as mean, median, mode, variance, etc.
Example
import statistics
data = [1, 2, 2, 3, 4]
print("Mean:", statistics.mean(data))
print("Median:", statistics.median(data))
print("Mode:", statistics.mode(data))
Math Module
Provides mathematical functions such as trigonometric calculations, logarithms,
factorials, and more.
Example
import math
print("Square root of 16:", math.sqrt(16))
print("Factorial of 5:", math.factorial(5))
print("Cosine of 45 degrees:", math.cos(math.radians(45)))
Numpy Library
Widely used for numerical computations with arrays, matrices, and linear algebra
functions.
Example:
import numpy as np
array = np.array([1, 2, 3, 4, 5])
4
print("Mean of array:", np.mean(array))
print("Sum of array:", np.sum(array))
Scipy Library
Built on Numpy, it provides additional functionality for optimization, integration, and
scientific computations.
Example
from scipy import integrate
# Define a function to integrate
result, _ = integrate.quad(lambda x: x**2, 0, 1)
print("Integral of x^2 from 0 to 1:", result)
5
3. Study of Python Libraries for ML application such as Pandas and
Matplotlib
For machine learning and data analysis, Python libraries like Pandas and Matplotlib are
essential for data manipulation and visualization.
Pandas
Provides data structures like Series and DataFrame for handling and analyzing data
efficiently.
Example:
import pandas as pd
data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35]}
df = pd.DataFrame(data)
print(df)
print("Mean Age:", df['Age'].mean())
Matplotlib
A visualization library used for creating static, interactive, and animated plots.
Example:
import matplotlib.pyplot as plt
x = [1, 2, 3, 4, 5]
y = [10, 20, 25, 30, 35]
plt.plot(x, y, marker='o', linestyle='--', color='r')
plt.title("Sample Line Plot")
plt.xlabel("X-axis")
plt.ylabel("Y-axis")
plt.show()
6
Program 4:Python Program for Simple Linear Regression.
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
# Generate some example data
np.random.seed(0)
X = 2 * np.random.rand(100, 1)
y = 4 + 3 * X + np.random.randn(100, 1)
# Split the data 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)
# Create and train the model
model = LinearRegression()
model.fit(X_train, y_train)
# Make predictions
y_pred = model.predict(X_test)
# Evaluate the model
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)
7
print(f"Mean Squared Error: {mse:.2f}")
print(f"R-squared: {r2:.2f}")
# Plotting the results
plt.scatter(X_test, y_test, color="black", label="Actual data")
plt.plot(X_test, y_pred, color="blue", linewidth=2, label="Fitted line")
plt.xlabel("X")
plt.ylabel("y")
plt.title("Simple Linear Regression")
plt.legend()
plt.show()
OUTPUT:
8
program5: Implementation of Multiple Linear Regression for House
Pricing Pricing Prediction using sklearn
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
# Load the dataset
data = pd.read_csv('house_prices.csv')
# Display the first few rows of the dataset
print(data.head())
# Selecting features and target variable
X = data[['Size', 'Bedrooms', 'Age']]
y = data['Price']
# Handling missing data
X = X.fillna(X.mean())
y = y.fillna(y.mean())
# Splitting the data into training and testing sets
9
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
random_state=42)
# Creating and training the model
model = LinearRegression()
model.fit(X_train, y_train)
# Making predictions on the testing set
y_pred = model.predict(X_test)
# Evaluating the model's performance
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)
print(f'Mean Squared Error: {mse}')
print(f'R-squared: {r2}')
# Model coefficients
print("Intercept:", model.intercept_)
print("Coefficients:", model.coef_)
coefficients = pd.DataFrame(model.coef_, X.columns, columns=['Coefficient'])
print(coefficients)
10
6. Implementation of Decision tree using sklearn and its parameter tuning
11
Importing necessary libraries
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, classification_report
from sklearn.datasets import load_iris
# Load dataset (for example, the Iris dataset)
data = load_iris()
X = data.data
y = data.target
# Split 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)
# Initialize a basic DecisionTreeClassifier
clf = DecisionTreeClassifier(random_state=42)
# Fit the model with the training data
clf.fit(X_train, y_train)
# Predict on the test set
y_pred = clf.predict(X_test)
12
# Evaluate model performance
print("Accuracy without tuning: ", accuracy_score(y_test, y_pred))
print("Classification Report:\n", classification_report(y_test, y_pred))
# Parameter tuning using GridSearchCV
param_grid = {
'criterion': ['gini', 'entropy'], # Different criteria for splitting
'splitter': ['best', 'random'], # Split strategy
'max_depth': [None, 10, 20, 30], # Depth of tree
'min_samples_split': [2, 5, 10], # Minimum number of samples to split a
node
'min_samples_leaf': [1, 2, 4], # Minimum number of samples to be at a
leaf node
'max_features': [None, 'auto', 'sqrt', 'log2'] # Number of features to consider
for the best split
# Using GridSearchCV for parameter tuning
grid_search = GridSearchCV(estimator=clf, param_grid=param_grid, cv=5,
n_jobs=-1, verbose=1)
# Fit GridSearchCV
grid_search.fit(X_train, y_train)
# Best parameters from GridSearchCV
13
print("Best Parameters: ", grid_search.best_params_)
# Predict with the best estimator from grid search
best_clf = grid_search.best_estimator_
y_pred_best = best_clf.predict(X_test)
# Evaluate performance with the tuned model
print("Accuracy with tuning: ", accuracy_score(y_test, y_pred_best))
print("Classification Report:\n", classification_report(y_test, y_pred_best))
OUTPUT:
Accuracy with tuning: 1.0
Classification Report:
precision recall f1-score support
0 1.00 1.00 1.00 10
1 1.00 1.00 1.00 9
2 1.00 1.00 1.00 11
accuracy 1.00 30
macro avg 1.00 1.00 1.00 30
weighted avg 1.00 1.00 1.00 30
7. Implementation of KNN using sklearn
14
# Import necessary libraries
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
# Load the dataset (Iris dataset)
iris = load_iris()
X = iris.data # Features
y = iris.target # Target labels
# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,
random_state=42)
# Create the KNN model with k=3
knn = KNeighborsClassifier(n_neighbors=3)
# Train the model
knn.fit(X_train, y_train)
# Make predictions
y_pred = knn.predict(X_test)
# Evaluate the model's performance
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy * 100:.2f}%")
OUTPUT:
Accuracy: 100.00%
8.Implementation of Logistic Regression using sklearn
15
# Import necessary libraries
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, confusion_matrix,
classification_report
from sklearn.datasets import load_iris
# Load a sample dataset
# Here, we're using the Iris dataset for simplicity.
# We'll use only two classes (binary classification) for logistic regression.
iris = load_iris()
X = iris.data
y = iris.target
# For binary classification, we'll select only two classes (e.g., class 0 and 1)
X = X[y != 2] # Select only class 0 and 1
y = y[y != 2] # Select only class 0 and 1
# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,
random_state=42)
# Create a Logistic Regression model
log_reg = LogisticRegression()
# Train the model
log_reg.fit(X_train, y_train)
16
# Make predictions on the test set
y_pred = log_reg.predict(X_test)
# Evaluate the model
accuracy = accuracy_score(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred)
class_report = classification_report(y_test, y_pred)
# Print the results
print("Accuracy:", accuracy)
print("\nConfusion Matrix:\n", conf_matrix)
print("\nClassification Report:\n", class_report)
OUTPUT:
Accuracy: 1.0
Confusion Matrix:
[[17 0]
[ 0 13]]
Classification Report:
precision recall f1-score support
0 1.00 1.00 1.00 17
1 1.00 1.00 1.00 13
accuracy 1.00 30
macro avg 1.00 1.00 1.00 30
weighted avg 1.00 1.00 1.00 30
9.Implementation of K-Means Clustering
17
import numpy as np
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt
# Generate synthetic data with 4 clusters
X, y_true = make_blobs(n_samples=300, centers=4, cluster_std=0.60,
random_state=0)
# Create a KMeans model with the number of clusters set to 4
kmeans = KMeans(n_clusters=4, random_state=0)
# Fit the model to the data
kmeans.fit(X)
# Predict the cluster labels for each data point
y_kmeans = kmeans.predict(X)
# Plotting the clusters and their centroids
plt.scatter(X[:, 0], X[:, 1], c=y_kmeans, s=50, cmap='viridis')
# Marking the centroids
centers = kmeans.cluster_centers_
plt.scatter(centers[:, 0], centers[:, 1], c='red', s=200, alpha=0.75, marker='X')
plt.title("K-Means Clustering")
18
plt.xlabel("Feature 1")
plt.ylabel("Feature 2")
plt.show()
OUTPUT:
19
