big data 9

  PRACTICAL NO – 9

Aim: Implementing Page Rank Algorithm Using Map-Reduce.

import numpy as np import scipy as sc import pandas as pd

from fractions import Fraction

def display_format(my_vector, my_decimal):

return np.round((my_vector).astype(np.float), decimals=my_decimal) my_dp = Fraction(1,3)

Mat = np.matrix([[0,0,1],

[Fraction(1,2),0,0],

[Fraction(1,2),1,0]]) Ex = np.zeros((3,3)) 

Ex[:] = my_dp beta = 0.7

Al = beta * Mat + ((1-beta) * Ex)

r = np.matrix([my_dp, my_dp, my_dp]) r = np.transpose(r)

previous_r = r

for i in range(1,100):

r = Al * r

print (display_format(r,3)) if (previous_r==r).all():

break previous_r = r

print ("Final:\n", display_format(r,3)) print ("sum", np.sum(r))

 

OUTPUT:

[[0.333]

[0.217]

[0.45 ]]

[[0.415]

[0.217]

[0.368]]

[[0.358]

[0.245]

[0.397]]

...

//Reduce upper matrix if need to

...

[[0.375]

[0.231]

[0.393]]

 

FINAL:

[[0.375]

[0.231]

[0.393]]

sum 0.9999999999999951

Comments

  1. import java.util.*;
    import java.io.*;
    public class PageRank {

    public int path[][] = new int[10][10];
    public double pagerank[] = new double[10];

    public void calc(double totalNodes) {

    double InitialPageRank;
    double OutgoingLinks = 0;
    double DampingFactor = 0.85;
    double TempPageRank[] = new double[10];
    int ExternalNodeNumber;
    int InternalNodeNumber;
    int k = 1; // For Traversing
    int ITERATION_STEP = 1;
    InitialPageRank = 1 / totalNodes;
    System.out.printf(" Total Number of Nodes :" + totalNodes + "\t Initial PageRank of All Nodes :" + InitialPageRank + "\n");

    // 0th ITERATION _ OR _ INITIALIZATION PHASE //

    for (k = 1; k <= totalNodes; k++) {
    this.pagerank[k] = InitialPageRank;
    }

    System.out.printf("\n Initial PageRank Values , 0th Step \n");
    for (k = 1; k <= totalNodes; k++) {
    System.out.printf(" Page Rank of " + k + " is :\t" + this.pagerank[k] + "\n");
    }

    while (ITERATION_STEP <= 2) // Iterations
    {
    // Store the PageRank for All Nodes in Temporary Array
    for (k = 1; k <= totalNodes; k++) {
    TempPageRank[k] = this.pagerank[k];
    this.pagerank[k] = 0;
    }

    for (InternalNodeNumber = 1; InternalNodeNumber <= totalNodes; InternalNodeNumber++) {
    for (ExternalNodeNumber = 1; ExternalNodeNumber <= totalNodes; ExternalNodeNumber++) {
    if (this.path[ExternalNodeNumber][InternalNodeNumber] == 1) {
    k = 1;
    OutgoingLinks = 0; // Count the Number of Outgoing Links for each ExternalNodeNumber
    while (k <= totalNodes) {
    if (this.path[ExternalNodeNumber][k] == 1) {
    OutgoingLinks = OutgoingLinks + 1; // Counter for Outgoing Links
    }
    k = k + 1;
    }
    // Calculate PageRank
    this.pagerank[InternalNodeNumber] += TempPageRank[ExternalNodeNumber] * (1 / OutgoingLinks);
    }
    }
    }

    System.out.printf("\n After " + ITERATION_STEP + "th Step \n");

    for (k = 1; k <= totalNodes; k++)
    System.out.printf(" Page Rank of " + k + " is :\t" + this.pagerank[k] + "\n");

    ITERATION_STEP = ITERATION_STEP + 1;
    }
    // Add the Damping Factor to PageRank
    for (k = 1; k <= totalNodes; k++) {
    this.pagerank[k] = (1 - DampingFactor) + DampingFactor * this.pagerank[k];
    }

    // Display PageRank
    System.out.printf("\n Final Page Rank : \n");
    for (k = 1; k <= totalNodes; k++) {
    System.out.printf(" Page Rank of " + k + " is :\t" + this.pagerank[k] + "\n");
    }

    }

    public static void main(String args[]) {
    int nodes, i, j, cost;
    Scanner in = new Scanner(System.in);
    System.out.println("Enter the Number of WebPages \n");
    nodes = in .nextInt();
    PageRank p = new PageRank();
    System.out.println("Enter the Adjacency Matrix with 1->PATH & 0->NO PATH Between two WebPages: \n");
    for (i = 1; i <= nodes; i++)
    for (j = 1; j <= nodes; j++) {
    p.path[i][j] = in .nextInt();
    if (j == i)
    p.path[i][j] = 0;
    }
    p.calc(nodes);

    }
    }

    ReplyDelete

Post a Comment

Popular posts from this blog

ML programs

big data 8

big data 6