Computer Laboratory-II B.E.

(Sem-I) [2023-24]

ASSIGNMENT No: 08
Title: Write a program to construct a Bayesian network considering medical data. Use this model to
demonstrate the diagnosis of heart patients using the standard Heart Disease Data Set (You can use
Java/Python ML library classes/API.

Problem Statement: To construct a Bayesian network considering medical data. Use this model to
demonstrate the diagnosis of heart patients using the standard Heart Disease Data Set (You can use
Java/Python ML library classes/API.

Prerequisite:
Basics of Python

Software Requirements: Jupyter

Hardware Requirements:
PIV, 2GB RAM, 500 GB HDD

Learning Objectives:

Learn to construct a Bayesian network considering medical data.

Outcomes:
After completion of this assignment students are able to understand how to construct a Bayesian
network considering medical data.

Theory:
A Bayesian network is a directed acyclic graph in which each edge corresponds to a conditional
dependency, and each node corresponds to a unique random variable.

Bayesian network consists of two major parts: a directed acyclic graph and a set of conditional
probability distributions
 The directed acyclic graph is a set of random variables represented by nodes.
 The conditional probability distribution of a node (random variable) is defined for
every possible outcome of the preceding causal node(s).

For illustration, consider the following example. Suppose we attempt to turn on our
computer, but the computer does not start (observation/evidence). We would like to know

38 Department of Artificial Intelligence and Data Science, DYPIEMR, Pune

Computer Laboratory-II B.E.(Sem-I) [2023-24]

which of the possible causes of computer failure is more likely. In this simplified
illustration, we assume only two possible causes of this misfortune: electricity failure and
computer malfunction.
The corresponding directed acyclic graph is depicted in below figure.

Fig: Directed acyclic graph representing two independent possible causes of a computer failure.

The goal is to calculate the posterior conditional probability distribution of each of the possible
unobserved causes given the observed evidence, i.e. P [Cause | Evidence].

Data Set:

Title: Heart Disease Databases

The Cleveland database contains 76 attributes, but all published experiments refer to using
a subset of 14 of them. In particular, the Cleveland database is the only one that has been
used by ML researchers to this date. The "Heartdisease" field refers to the presence of
heart disease in the patient. It is integer valued from 0 (no presence) to 4.
Database: 0 1 2 3 4 Total
Cleveland: 164 55 36 35 13 303

Attribute Information:
1. age: age in years

39 Department of Artificial Intelligence and Data Science, DYPIEMR, Pune

Computer Laboratory-II B.E.(Sem-I) [2023-24]

2. sex: sex (1 = male; 0 = female)

3. cp: chest pain type
 Value 1: typical angina
 Value 2: atypical angina
 Value 3: non-anginal pain
 Value 4: asymptomatic
4. trestbps: resting blood pressure (in mm Hg on admission to the hospital)
5. chol: serum cholestoral in mg/dl
6. fbs: (fasting blood sugar > 120 mg/dl) (1 = true; 0 = false)
7. restecg: resting electrocardiographic results
 Value 0: normal
 Value 1: having ST-T wave abnormality (T wave inversions and/or ST
elevation or depression of > 0.05 mV)
 Value 2: showing probable or definite left ventricular hypertrophy by
Estes'criteria
8. thalach: maximum heart rate achieved
9. exang: exercise induced angina (1 = yes; 0 = no)
10. oldpeak = ST depression induced by exercise relative to rest
11. slope: the slope of the peak exercise ST segment
 Value 1: upsloping
 Value 2: flat
 Value 3: downsloping
12. ca = number of major vessels (0-3) colored by flourosopy
13. thal: 3 = normal; 6 = fixed defect; 7 = reversable defect
14. Heartdisease: It is integer valued from 0 (no presence) to 4. Diagnosis of heart
disease (angiographic disease status)
Some instance from the dataset:

age sex cp trestbps chol fbs restecg thalach exang oldpeak slope ca thal Heartdisease
63 1 1 145 233 1 2 150 0 2.3 3 0 6 0
67 1 4 160 286 0 2 108 1 1.5 2 3 3 2
67 1 4 120 229 0 2 129 1 2.6 2 2 7 1
41 0 2 130 204 0 2 172 0 1.4 1 0 3 0
62 0 4 140 268 0 2 160 0 3.6 3 2 3 3
60 1 4 130 206 0 2 132 1 2.4 2 2 7 4

Program:

40 Department of Artificial Intelligence and Data Science, DYPIEMR, Pune

Computer Laboratory-II B.E.(Sem-I) [2023-24]

import numpy as np import csv

import pandas as pd
from pgmpy.models import BayesianModel
from pgmpy.estimators import MaximumLikelihoodEstimator from pgmpy.inference import
VariableElimination

#read Cleveland Heart Disease data heartDisease = pd.read_csv('heart.csv')

heartDisease = heartDisease.replace('?',np.nan)

#display the data print('Few examples from the dataset are given below')
print(heartDisease.head())

#Model Bayesian Network Model=BayesianModel([('age','trestbps'),('age','fbs'),

('sex','trestbps'),('exang','trestbps'),('trestbps','heartdise
ase'),('fbs','heartdisease'),('heartdisease','restecg'),
('heartdisease','thalach'),('heartdisease','chol')])

#Learning CPDs using Maximum Likelihood Estimators print('\n Learning CPD using Maximum
likelihood estimators') model.fit(heartDisease,estimator=MaximumLikelihoodEstimator)

# Inferencing with Bayesian Network print('\n Inferencing with Bayesian Network:')

HeartDisease_infer = VariableElimination(model)

#computing the Probability of HeartDisease given Age print('\n 1. Probability of HeartDisease

given Age=30') q=HeartDisease_infer.query(variables=['heartdisease'],evidence
={'age':28})
print(q['heartdisease'])

#computing the Probability of HeartDisease given cholesterol print('\n 2. Probability of HeartDisease

given cholesterol=100') q=HeartDisease_infer.query(variables=['heartdisease'],evidence
={'chol':100})
print(q['heartdisease'])

Output:

Few examples from the dataset are given below

41 Department of Artificial Intelligence and Data Science, DYPIEMR, Pune

Computer Laboratory-II B.E.(Sem-I) [2023-24]

age sex cp trestbps ...slope ca thal

heartdisease
0 63 1 1 145 ... 3 0 6 0
1 67 1 4 160 ... 2 3 3 2
2 67 1 4 120 ... 2 2 7 1
3 37 1 3 130 ... 3 0 3 0
4 41 0 2 130 ... 1 0 3 0

[5 rows x 14 columns]

Learning CPD using Maximum likelihood

estimators Inferencing with Bayesian Network:

1. Probability of HeartDisease given Age=28

╒════════════════╤═════════════════════╕
│ heartdisease │ phi(heartdisease) │
╞════════════════╪═════════════════════╡
│ heartdisease_0 │ 0.6791 │
├────────────────┼─────────────────────┤
│ heartdisease_1 │ 0.1212 │
├────────────────┼─────────────────────┤
│ heartdisease_2 │ 0.0810 │
├────────────────┼─────────────────────┤
│ heartdisease_3 │ 0.0939 │
├────────────────┼─────────────────────┤
│ heartdisease_4 │ 0.0247 │
╘════════════════╧═════════════════════╛

42 Department of Artificial Intelligence and Data Science, DYPIEMR, Pune

Computer Laboratory-II B.E.(Sem-I) [2023-24]

2. Probability of HeartDisease given cholesterol=100

╒════════════════╤═════════════════════╕
│ heartdisease │ phi(heartdisease) │
╞════════════════╪═════════════════════╡
│ heartdisease_0 │ 0.5400 │
├────────────────┼─────────────────────┤
│ heartdisease_1 │ 0.1533 │
├────────────────┼─────────────────────┤
│ heartdisease_2 │ 0.1303 │
├────────────────┼─────────────────────┤
│ heartdisease_3 │ 0.1259 │
├────────────────┼─────────────────────┤
│ heartdisease_4 │ 0.0506 │
╘════════════════╧═════════════════════╛

Conclusion: This way constructed a Bayesian network considering medical data.

43 Department of Artificial Intelligence and Data Science, DYPIEMR, Pune

Computer Laboratory-II B.E.(Sem-I) [2023-24]

ASSIGNMENT No: 09
Title: Implement Agglomerative hierarchical clustering algorithm using appropriate dataset.
Problem Statement: Implement Agglomerative hierarchical clustering algorithm using appropriate
dataset

Prerequisite:
Basics of Python

Software Requirements: Jupyter

Hardware Requirements:
PIV, 2GB RAM, 500 GB HDD

Learning Objectives:

Learn to Implement Agglomerative hierarchical clustering algorithm using appropriate dataset

Outcomes:
After completion of this assignment students are able to understand how to Implement Agglomerative
hierarchical clustering algorithm using appropriate dataset

Theory:
In data mining and statistics, hierarchical clustering analysis is a method of clustering analysis that
seeks to build a hierarchy of clusters i.e. tree-type structure based on the hierarchy.
In machine learning, clustering is the unsupervised learning technique that groups the data based on
similarity between the set of data. There are different-different types of clustering algorithms in
machine learning. Connectivity-based clustering: This type of clustering algorithm builds the cluster
based on the connectivity between the data points. Example: Hierarchical clustering
 Centroid-based clustering: This type of clustering algorithm forms around the centroids of the
data points. Example: K-Means clustering, K-Mode clustering
 Distribution-based clustering: This type of clustering algorithm is modeled using statistical
distributions. It assumes that the data points in a cluster are generated from a particular probability
distribution, and the algorithm aims to estimate the parameters of the distribution to group similar
data points into clusters Example: Gaussian Mixture Models (GMM)
 Density-based clustering: This type of clustering algorithm groups together data points that are
in high-density concentrations and separates points in low-concentrations regions. The basic idea

45 Department of Artificial Intelligence and Data Science, DYPIEMR, Pune

Computer Laboratory-II B.E.(Sem-I) [2023-24]

is that it identifies regions in the data space that have a high density of data points and groups
those points together into clusters. Example: DBSCAN(Density-Based Spatial Clustering of
Applications with Noise)

Hierarchical clustering
Hierarchical clustering is a connectivity-based clustering model that groups the data points together
that are close to each other based on the measure of similarity or distance. The assumption is that data
points that are close to each other are more similar or related than data points that are farther apart.
A dendrogram, a tree-like figure produced by hierarchical clustering, depicts the hierarchical
relationships between groups. Individual data points are located at the bottom of the dendrogram,
while the largest clusters, which include all the data points, are located at the top. In order to generate
different numbers of clusters, the dendrogram can be sliced at various heights.
The dendrogram is created by iteratively merging or splitting clusters based on a measure of similarity
or distance between data points. Clusters are divided or merged repeatedly until all data points are
contained within a single cluster, or until the predetermined number of clusters is attained.
We can look at the dendrogram and measure the height at which the branches of the dendrogram form
distinct clusters to calculate the ideal number of clusters. The dendrogram can be sliced at this height
to determine the number of clusters.

Types of Hierarchical Clustering

Basically, there are two types of hierarchical Clustering:

1. Agglomerative Clustering
2. Divisive clustering
Hierarchical Agglomerative Clustering
It is also known as the bottom-up approach or hierarchical agglomerative clustering (HAC). A
structure that is more informative than the unstructured set of clusters returned by flat clustering. This
clustering algorithm does not require us to prespecify the number of clusters. Bottom-up algorithms
treat each data as a singleton cluster at the outset and then successively agglomerate pairs of clusters
until all clusters have been merged into a single cluster that contains all data.

Agglomerative Clustering is one of the most common hierarchical clustering techniques. Dataset –
Credit Card Dataset.

Assumption: The clustering technique assumes that each data point is similar enough to the other data
points that the data at the starting can be assumed to be clustered in 1 cluster. Step 1: Importing the
required libraries

import pandas as pd

46 Department of Artificial Intelligence and Data Science, DYPIEMR, Pune

Computer Laboratory-II B.E.(Sem-I) [2023-24]

import numpy as np

import matplotlib.pyplot as plt

from sklearn.decomposition import PCA

from sklearn.cluster import AgglomerativeClustering

from sklearn.preprocessing import StandardScaler, normalize

from sklearn.metrics import silhouette_score

import scipy.cluster.hierarchy as shc

Step 2: Loading and Cleaning the data

# Changing the working location to the location of the file

cd C:\Users\Dev\Desktop\Kaggle\Credit_Card

X = pd.read_csv('CC_GENERAL.csv')

# Dropping the CUST_ID column from the data

X = X.drop('CUST_ID', axis = 1)

# Handling the missing values

X.fillna(method ='ffill', inplace = True)

Step 3: Preprocessing the data

# Scaling the data so that all the features become comparable
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Normalizing the data so that the data approximately

# follows a Gaussian distribution
X_normalized = normalize(X_scaled)

# Converting the numpy array into a pandas DataFrame

X_normalized = pd.DataFrame(X_normalized)

47 Department of Artificial Intelligence and Data Science, DYPIEMR, Pune

Computer Laboratory-II B.E.(Sem-I) [2023-24]

Step 4: Reducing the dimensionality of the Data

pca = PCA(n_components = 2)
X_principal = pca.fit_transform(X_normalized)
X_principal = pd.DataFrame(X_principal)
X_principal.columns = ['P1', 'P2']

Dendrograms are used to divide a given cluster into many different clusters. Step 5: Visualizing the
working of the Dendrograms
plt.figure(figsize =(8, 8))
plt.title('Visualising the data')
Dendrogram = shc.dendrogram((shc.linkage(X_principal, method ='ward')))

To determine the optimal number of clusters by visualizing the data, imagine all the horizontal lines as
being completely horizontal and then after calculating the maximum distance between any two
horizontal lines, draw a horizontal line in the maximum distance calculated.

The above image shows that the optimal number of clusters should be 2 for the given data. Step 6:
Building and Visualizing the different clustering models for different values of k a) k = 2

ac2 = AgglomerativeClustering(n_clusters = 2)

# Visualizing the clustering

48 Department of Artificial Intelligence and Data Science, DYPIEMR, Pune

Computer Laboratory-II B.E.(Sem-I) [2023-24]

plt.figure(figsize =(6, 6))

plt.scatter(X_principal['P1'], X_principal['P2'],
c = ac2.fit_predict(X_principal), cmap ='rainbow')
plt.show()

ac3 = AgglomerativeClustering(n_clusters = 3)

plt.figure(figsize =(6, 6))

plt.scatter(X_principal['P1'], X_principal['P2'],
c = ac3.fit_predict(X_principal), cmap ='rainbow')
plt.show()

ac4 = AgglomerativeClustering(n_clusters = 4)

plt.figure(figsize =(6, 6))

plt.scatter(X_principal['P1'], X_principal['P2'],
c = ac4.fit_predict(X_principal), cmap ='rainbow')
plt.show()

ac5 = AgglomerativeClustering(n_clusters = 5)

plt.figure(figsize =(6, 6))

plt.scatter(X_principal['P1'], X_principal['P2'],

49 Department of Artificial Intelligence and Data Science, DYPIEMR, Pune

Computer Laboratory-II B.E.(Sem-I) [2023-24]

c = ac5.fit_predict(X_principal), cmap ='rainbow')

plt.show()

ac6 = AgglomerativeClustering(n_clusters = 6)

plt.figure(figsize =(6, 6))

plt.scatter(X_principal['P1'], X_principal['P2'],
c = ac6.fit_predict(X_principal), cmap ='rainbow')
plt.show()

We now determine the optimal number of clusters using a mathematical technique. Here, We will use
the Silhouette Scores for the purpose. Step 7: Evaluating the different models and Visualizing the
results.
k = [2, 3, 4, 5, 6]

# Appending the silhouette scores of the different models to the list

silhouette_scores = []
silhouette_scores.append(
silhouette_score(X_principal, ac2.fit_predict(X_principal)))
silhouette_scores.append(
silhouette_score(X_principal, ac3.fit_predict(X_principal)))
silhouette_scores.append(
silhouette_score(X_principal, ac4.fit_predict(X_principal)))
silhouette_scores.append(
silhouette_score(X_principal, ac5.fit_predict(X_principal)))
silhouette_scores.append(
silhouette_score(X_principal, ac6.fit_predict(X_principal)))

# Plotting a bar graph to compare the results

plt.bar(k, silhouette_scores)
plt.xlabel('Number of clusters', fontsize = 20)
plt.ylabel('S(i)', fontsize = 20)
plt.show()

50 Department of Artificial Intelligence and Data Science, DYPIEMR, Pune

Computer Laboratory-II B.E.(Sem-I) [2023-24]

with the help of the silhouette scores, it is concluded that the optimal number of clusters for the given
data and clustering technique is 2.

Conclusion :- This way Implemented Agglomerative hierarchical clustering algorithm using appropriate
dataset

51 Department of Artificial Intelligence and Data Science, DYPIEMR, Pune

Computer Laboratory-II B.E.(Sem-I) [2023-24]

ASSIGNMENT No: 10
Title: Implement Page Rank Algorithm. (Use python or beautiful soup for implementation).
Problem Statement: Implement Page Rank Algorithm. (Use python or beautiful soup for
implementation).

Prerequisite:
Basics of Python

Software Requirements: Jupyter

Hardware Requirements:
PIV, 2GB RAM, 500 GB HDD

Learning Objectives:

Learn to Implement Page Rank Algorithm. (Use python or beautiful soup for implementation).

Outcomes:
After completion of this assignment students are able to understand how to Implement Page Rank
Algorithm. (Use python or beautiful soup for implementation).

Theory:
PageRank (PR) is an algorithm used by Google Search to rank websites in their search engine results.
PageRank was named after Larry Page, one of the founders of Google. PageRank is a way of measurin g
the importance of website pages. According to Google:
PageRank works by counting the number and quality of links to a page to determine a rough estimate
of how important the website is. The underlying assumption is that more important websites are likely
to receive more links from other websites.

It is not the only algorithm used by Google to order search engine results, but it is the first algorithm
that was used by the company, and it is the best-known.
The above centrality measure is not implemented for multi-graphs.
Algorithm
The PageRank algorithm outputs a probability distribution used to represent the likelihood that a person
randomly clicking on links will arrive at any particular page. PageRank can be calculated for collectio ns
of documents of any size. It is assumed in several research papers that the distributio n is evenly divided
among all documents in the collection at the beginning of the computational process. The PageRank
computations require several passes, called “iterations”, through the collection to adjust approximate
PageRank values to more closely reflect the theoretical true value.

53 Department of Artificial Intelligence and Data Science, DYPIEMR, Pune

Computer Laboratory-II B.E.(Sem-I) [2023-24]

Simplified algorithm
Assume a small universe of four web pages: A, B, C, and D. Links from a page to itself, or multiple outbound links
from one single page to another single page, are ignored. PageRank is initialized to the same value for all pages.
In the original form of PageRank, the sum of PageRank over all pages was the total number of pages on the web
at that time, so each page in this example would have an initial value of 1. However, later versions of PageRank,
and the remainder of this section, assume a probability distribution between 0 and 1. Hence the initial value for
each page in this example is 0.25.
The PageRank transferred from a given page to the targets of its outbound links upon the next iteration is
divided equally among all outbound links.
If the only links in the system were from pages B, C, and D to A, each link would transfer 0.25 PageRank to A
upon the next iteration, for a total of 0.75.

Suppose instead that page B had a link to pages C and A, page C had a link to page A, and page D had links to all
three pages. Thus, upon the first iteration, page B would transfer half of its existing value, or 0.125, to page A
and the other half, or 0.125, to page C. Page C would transfer all of its existing value , 0.25, to the only page it
links to, A. Since D had three outbound links, it would transfer one -third of its existing value, or approximately
0.083, to A. At the completion of this iteration, page A will have a PageRank of approximately 0.458.

In other words, the PageRank conferred by an outbound link is equal to the document’s own PageRank score
divided by the number of outbound links L( ).
In the general case, the PageRank value for any page u can be expressed as:
i.e. the PageRank value for a page u is dependent on the PageRank values for each page v contained in the set
Bu (the set containing all pages linking to page u), divided by the number L(v) of links from page v. The
algorithm involves a damping factor for the calculation of the PageRank. It is like the income tax which the govt
extracts from one despite paying him itself.

Following is the code for the calculation of the Page rank.

def pagerank(G, alpha=0.85, personalization=None,

max_iter=100, tol=1.0e-6, nstart=None, weight='weight',
dangling=None):
"""Return the PageRank of the nodes in the graph.

PageRank computes a ranking of the nodes in the graph G based on

the structure of the incoming links. It was originally designed as
an algorithm to rank web pages.

Parameters
----------
G : graph
A NetworkX graph. Undirected graphs will be converted to a directed
graph with two directed edges for each undirected edge.

alpha : float, optional

Damping parameter for Page Rank, default=0.85.

personalization: dict, optional

The "personalization vector" consisting of a dictionary with a
key for every graph node and nonzero personalization value for each node.

54 Department of Artificial Intelligence and Data Science, DYPIEMR, Pune

Computer Laboratory-II B.E.(Sem-I) [2023-24]

By default, a uniform distribution is used .

max_iter : integer, optional

Maximum number of iterations in power method eigenvalue solver.

tol : float, optional

Error tolerance used to check convergence in power method solver.

nstart : dictionary, optional

Starting value of PageRank iteration for each node.

weight : key, optional

Edge data key to use as weight. If None weights are set to 1.

dangling: dict, optional

The outedges to be assigned to any "dangling" nodes, i.e., nodes withou t
any outedges. The dict key is the node the outedge points to and the dict
value is the weight of that outedge. By default, dangling nodes are given
outedges according to the personalization vector (uniform if not
specified). This must be selected to result in an irreducible transition
matrix (see notes under google_matrix). It may be common to have the
dangling dict to be the same as the personalization dict.

Returns
-------
pagerank : dictionary
Dictionary of nodes with PageRank as value

Notes
-----
The eigenvector calculation is done by the power iteration method
and has no guarantee of convergence. The iteration will stop
after max_iter iterations or an error tolerance of
number_of_nodes(G)*tol has been reached.

The PageRank algorithm was designed for directed graphs but this
algorithm does not check if the input graph is directed and will
execute on undirected graphs by converting each edge in the
directed graph to two edges.

"""
if len(G) == 0:
return {}

if not G.is_directed():
D = G.to_directed()
else:
D = G

# Create a copy in (right) stochastic form

W = nx.stochastic_graph(D, weight=weight)
N = W.number_of_nodes()

# Choose fixed starting vector if not given

55 Department of Artificial Intelligence and Data Science, DYPIEMR, Pune

Computer Laboratory-II B.E.(Sem-I) [2023-24]

if nstart is None:
x = dict.fromkeys(W, 1.0 / N)
else:
# Normalized nstart vector
s = float(sum(nstart.values()))
x = dict((k, v / s) for k, v in nstart.items())

if personalization is None:

# Assign uniform personalization vector if not given

p = dict.fromkeys(W, 1.0 / N)
else:
missing = set(G) - set(personalization)
if missing:
raise NetworkXError('Personalization dictionary '
'must have a value for every node. '
'Missing nodes %s' % missing)
s = float(sum(personalization.values()))
p = dict((k, v / s) for k, v in personalization.items())

if dangling is None:

# Use personalization vector if dangling vector not specified

dangling_weights = p
else:
missing = set(G) - set(dangling)
if missing:
raise NetworkXError('Dangling node dictionary '
'must have a value for every node. '
'Missing nodes %s' % missing)
s = float(sum(dangling.values()))
dangling_weights = dict((k, v/s) for k, v in dangling.items())
dangling_nodes = [n for n in W if W.out_degree(n, weight=weight) == 0.0]

# power iteration: make up to max_iter iterations

for _ in range(max_iter):
xlast = x
x = dict.fromkeys(xlast.keys(), 0)
danglesum = alpha * sum(xlast[n] for n in dangling_nodes)
for n in x:

# this matrix multiply looks odd because it is

# doing a left multiply x^T=xlast^T*W
for nbr in W[n]:
x[nbr] += alpha * xlast[n] * W[n][nbr][weight]
x[n] += danglesum * dangling_weights[n] + (1.0 - alpha) * p[n]

# check convergence, l1 norm

err = sum([abs(x[n] - xlast[n]) for n in x])
if err < N*tol:
return x
raise NetworkXError('pagerank: power iteration failed to converge '
'in %d iterations.' % max_iter)
The above code is the function that has been implemented in the networkx library.
To implement the above in networkx, you will have to do the following:

56 Department of Artificial Intelligence and Data Science, DYPIEMR, Pune

Computer Laboratory-II B.E.(Sem-I) [2023-24]

>>> import networkx as nx

>>> G=nx.barabasi_albert_graph(60,41)
>>> pr=nx.pagerank(G,0.4)
>>> pr
Below is the output, you would obtain on the IDLE after required installations.
{0: 0.012774147598875784, 1: 0.013359655345577266, 2: 0.013157355731377924,
3: 0.012142198569313045, 4: 0.013160014506830858, 5: 0.012973342862730735,
6: 0.012166706783753325, 7: 0.011985935451513014, 8: 0.012973502696061718,
9: 0.013374146193499381, 10: 0.01296354505412387, 11: 0.013163220326063332,
12: 0.013368514624403237, 13: 0.013169335617283102, 14: 0.012752071800520563,
15: 0.012951601882210992, 16: 0.013776032065400283, 17: 0.012356820581336275,
18: 0.013151652554311779, 19: 0.012551059531065245, 20: 0.012583415756427995,
21: 0.013574117265891684, 22: 0.013167552803671937, 23: 0.013165528583400423,
24: 0.012584981049854336, 25: 0.013372989228254582, 26: 0.012569416076848989,
27: 0.013165322299539031, 28: 0.012954300960607157, 29: 0.012776091973397076,
30: 0.012771016515779594, 31: 0.012953404860268598, 32: 0.013364947854005844,
33: 0.012370004022947507, 34: 0.012977539153099526, 35: 0.013170376268827118,
36: 0.012959579020039328, 37: 0.013155319659777197, 38: 0.013567147133137161,
39: 0.012171548109779459, 40: 0.01296692767996657, 41: 0.028 089802328702826,
42: 0.027646981396639115, 43: 0.027300188191869485, 44: 0.02689771667021551,
45: 0.02650459107960327, 46: 0.025971186884778535, 47: 0.02585262571331937,
48: 0.02565482923824489, 49: 0.024939722913691394, 50: 0.02458271197701402,
51: 0.024263128557312528, 52: 0.023505217517258568, 53: 0.023724311872578157,
54: 0.02312908947188023, 55: 0.02298716954828392, 56: 0.02270220663300396,
57: 0.022060403216132875, 58: 0.021932442105075004, 59: 0.021643288632623502}

Conclusion:- Thus, this way the centrality measure of Page Rank is calculated for the given graph.

57 Department of Artificial Intelligence and Data Science, DYPIEMR, Pune