Metodi di accelerazione per il calcolo delPageRankAndrea FavilliEstate 2014

Indice1 Un breve riassunto: il problema, risoluzione standard e relative questioni di

inefficienza. 21.1 Piano della trattazione. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 L’approccio Arnoldi-Extrapolation (Wu-Wei, 2010) 42.1 Prodotti ”veloci” matrice-vettore: implementazione e valutazione costo. . 42.2 L’iterazione di Arnoldi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62.3 Algoritmo Arnoldi-Type per il calcolo del PageRank. (Golub-Greif, 2004) 82.4 Una procedura di estrapolazione ai valori di Ritz. . . . . . . . . . . . . . . 112.5 Algoritmo Arnoldi-Extrapolation per il calcolo del PageRank. . . . . . . . 132.6 Sperimentazioni numeriche. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203 L’approccio Rational Extrapolation (Brezinski-Zaglia, 2008) 233.1 Calcolo simultaneo dei vettori di Rank. . . . . . . . . . . . . . . . . . . . . . 233.2 Una procedura di interpolazione con base di Lagrange. . . . . . . . . . . 243.3 Una procedura d’interpolazione più semplice. . . . . . . . . . . . . . . . . . 303.4 Interpolazione mediante minimizzazione del residuo. . . . . . . . . . . . . 333.5 Sperimentazioni numeriche. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354 Conclusioni: l’idea vincente 42

5 Appendice: costruzione di matrici di adiacenza dalla rete Internet. 43

1

1 Un breve riassunto: il problema, risoluzione standarde relative questioni di inefficienza.

Supponiamo di avere a disposizione una rete di siti web, interconnessi mediante lapresenza di link: sia M la matrice di adiacenza rappresentante tale rete, ossiaMij = {1 se il sito i contiene un link al sito j0 altrimentiCostruire il vettore di PageRank significa essenzialmente dare a ciascun sito un gradodi importanza (compreso tra 0 e 1, indipendente dal contenuto) seguendo la regolaper cui un sito è tanto più importante quanto spesso è citato mediante link da sitialtrettanto importanti. In altre parole, ciascun nodo della rete ripartisce in parti ugualiil suo Rank ai nodi ad esso adiacenti e il Rank totale di un nodo è dato semplicementedalla somma dei valori attribuiti da parte dei siti sui quali esiste un link al suddetto.

Vediamo di formalizzare il problema: se xi rappresenta l’importanza del sito i, questaè calcolata per quanto detto nel modo seguentexi = n∑

j=1 Mijxjdj

(1)dove dj rappresenta il numero di link presenti sul sito j , assumendo per adesso dj 6= 0.In termini matrice-vettore la (1) è equivalente a

xT = xTD−1M (2)posto D = diag{d1, . . . , dn}, si tratta di calcolare l’autovettore sinistro della matriceP := D−1M corrispondente all’autovalore 1.

È tuttavia necessario modificare la (2), in quanto sono indispensabili alcuni accor-gimenti.• Possono esistere, e sono frequenti, pagine web non contenenti link (danglingnodes): assumiamo che una pagina dangling conferisca eguale importanza atutti i siti della rete. Per fare ciò sostituiamo P con P := P + feT /n, dove

eT = [1 1 . . . 1] efi = {1 se il sito i non contiene link0 altrimenti

• Il teorema di Perron-Frobenius ci assicura l’unicità di 1 come autovalore dimodulo massimo e la positività dell’1-autovettore sinistro a patto che la matriceP sia irriducibile e positiva: affinchè ciò avvenga sempre andiamo a considerarela matrice Pα := αP + (1− α)evT , con E := evT matrice di rango 1.Il valore di default di α è 0.85, quest’utlimo rappresenta la probabilità che il genericoutente navighi seguendo effettivamente il grafo di rete: assumiamo che con probabilità(1−α) l’utente possa saltare casualmente da un nodo all’altro, si sceglie perciò v = 1

nein modo da rendere ogni possibile ”salto” equiprobabile.2

Il problema del PageRank può essere scritto definitivamente nella forma:xT = xT Pα (3)o equivalentemente possiamo calcolarci l’1-autovettore destro della traspostaPTα x = x. (4)Una prima idea per il calcolo di x è data dall’applicazione del metodo delle potenze:si sceglie un vettore casuale y(0), lo si normalizza ottenendo x(0) e si applica più voltela seguente iterazione finchè ||x(k+1) − x(k )|| < ε , con ε > 0 opportunamente fissato.

y(k+1) = PTα x(k )x(k+1) = y(k+1)

||y(k+1)||L’autovalore di modulo massimo, nel nostro caso 1, è unico: questo fatto consentesempre la convergenza dell’iterazione delle potenze. Poichè il secondo autovalore inmodulo di PTα è proprio α si avrà una convergenza alla velocità di αk , comportandouna crescita asintotica di iterazioni scegliendo valori di α molto vicini a 1, vedi figura.

Figura 1: il grafico mostra il crescere delle iterazioni necessarie alla convergenza conl’aumentare del coefficiente α , rete di 200 nodi, ε = 10−13.1.1 Piano della trattazione.Calcolare il vettore di PageRank con valori di α molto vicini a 1 è alla base di problemidi sicurezza web: sfruttare il metodo delle potenze puro rallenterebbe il procedimen-to non poco, noi ci proponiamo di mostrare e implementare metodi alternativi checonsentano performance migliori.

3

• Seguendo gli studi di Gang Wu e Yimin Wei (2010) sfrutteremo l’iterazione diArnoldi, migliorata mediante estrapolazione ai primi tre autovalori in modulo,implementando il cosiddetto algoritmo Arnoldi-Extrapolation.• Eseguiremo implementazioni di svariate forme di interpolazione per poter suc-cessivamente estrapolare inmpiegando un numero costante di operazioni il va-lore dei vettori di rank per arbitrari α . La teoria sviluppata in questa secondaparte è di Brezinski e Redivo-Zaglia (2008), per quelli che sono detti algoritmidi Rational Extrapolation.• Spazio anche a valutazioni di costo, sperimentazioni numeriche e confronti trale due linee intraprese.• In appendice forniremo soluzioni per il ricavo di matrici di adiacenza dalla reteInternet.Il codice utilizzato per le implementazioni è scritto in linguaggio Fortran 95 con fre-quenti utilizzi della libreria di algebra lineare numerica LAPACK, in appendice utiliz-zeremo codice Octave/MATLAB. Si assume di codificare le matrici di adiacenza comefiles testuali contenenti in apertura i numeri dei nodi e dei valori non nulli, il tutto èseguito dalle coppie (i, j) tali che Mij = 1.

2 L’approccio Arnoldi-Extrapolation (Wu-Wei, 2010)

2.1 Prodotti ”veloci” matrice-vettore: implementazione e valutazio-ne costo.Vogliamo anzitutto scrivere una subroutine volta a calcolare il prodotto PTα v, per qual-siasi v ∈ Rn a componenti positive, sfruttando la sparsità della matrice PTα ∈ Rn×n(assumeremo m < n2 il numero di valori non nulli della matrice). Come vedremo ta-le calcolo risulterà essere utile non solo nello sviluppo dell’algoritmo di Arnoldi, manell’intero seguito.

Premettendo che ET = ( 1neeT )T = 1

neeT = E e che fT v = ||v||1 − ||PT v||1 = eT v −eT (PT v), si effettuano opportune manipolazioni algebriche:

PTα v = [αP + (1− α)E ]T v = [αPT + (1− α)E ] v = αPT v + (1− α)Ev == α(P + feT /n)T v + (1− α)Ev = α(PT + efT /n)v + (1− α)Ev == αPT v + αe(fT v)/n+ Ev− αEv == αPT v + αe[eT v− eT (PT v)]/n+ e(eT v)/n− αe(eT v)/n == αPT v− αeeT (PT v)/n+ e(eT v)/n == αPT v + [eT v− αeT (PT v)]e/n.

4

Calcolare un prodotto matrice sparsa/vettore consta essenzialmente di tre fasi:1. Il calcolo di PT v, al costo di m prodotti ed altrettante somme, in totale 2moperazioni aritmetiche.2. Il calcolo del prodotto scalare eT v, al costo standard di n− 1 operazioni aritme-tiche, si tratta soltanto di sommare le componenti di v.3. Il calcolo del prodotto scalare eT (PT v) al costo di n− 1 operazioni aritmetiche,come al punto 2.Sono inoltre necessarie n operazioni per calcolare αPT v e altrettante per la sommafinale dei due vettori: in totale abbiamo 4n+ 2m+ 1 operazioni.Passiamo alle questioni implementative: si è supposto di rappresentare la matrice

P non come un array bidimensionale, ma mediante l’uso degli array semplici i, j ∈ Rme d ∈ Rn. I vettori i, j sono tali che Mik jk = 1, ∀k = 1, . . . , m mentre di è il numero di1 sulla riga i-esima di M .Per eseguire il prodotto PT v è sufficiente inizializzare un array a di dimensione n eper ogni k sommare ad ajk (scelgo j e non i perchè stiamo moltiplicando PT ) il valorevikdik

. Appare ovvio il fatto che ogni dik sarà non nullo, visto che l’indice occorre in i edunque avrà almeno un 1 sulla riga i-esima non essendo di conseguenza ”dangling”.Vediamo il codice:1 SUBROUTINE prodotto(i,j,d,m,n,x,alpha)23 IMPLICIT NONE45 ! Parametri formali.6 INTEGER , PARAMETER :: dp=KIND (0.d0)7 INTEGER , DIMENSION(m) :: i, j8 INTEGER , DIMENSION(n) :: d9 REAL(dp), DIMENSION(n) :: x

10 INTEGER :: m, n11 REAL(dp) :: alpha1213 ! Variabili d’ambiente.14 INTEGER :: k15 REAL(dp), DIMENSION(n) :: ptx1617 ptx = 018 DO k=1,m19 ptx(j(k)) = ptx(j(k)) + x(i(k))/d(i(k))20 END DO2122 x = alpha * ptx + (SUM(x) - alpha * SUM(ptx)) / n2324 END SUBROUTINENella subroutine la variabile x rappresenta in ingresso proprio il vettore v, mentre inuscita riporta il prodotto finale cercato. Ricordiamo che la funzione SUM restituisce lasomma delle componenti di un array.

5

2.2 L’iterazione di ArnoldiIntroduciamo quello che sarà il nodo fondamentale del nostro procedimento, ma cheallo stesso tempo si rivela un algortimo interessante per il calcolo di autovettori ingenerale, nonostante le palesi difficoltà di natura numerica che questo comporta.Definizione 1. Sia A ∈ Rn×n, b ∈ Rn; chiamo sottospazio di Krylov di dimensione kil seguente

Kk (A, b) = Span{b, Ab, A2b, . . . , Ak−1b}L’iterazione di Arnoldi consiste nel costruire una base ortonormale del suddettosottospazio che possa essere considerata una grossolana approssimazione dei mag-giori k autovettori in modulo di A, per raggiungere l’ortonormalizzazione si utilizzal’algoritmo di Gram-Schmidt.I ”prodotti” sono la matrice V ∈ Rn×(k+1) dei vettori di Krylov e H ∈ R(k+1)×k la cuisottomatrice quadrata H ∈ Rk×k ottenuta togliendo l’ultima riga rappresenta la pro-iezione di A in Kk (A, b) scritta nella base dei vettori di Krylov, vedremo a breve lapeculiare costruzione di H .Elenchiamo alcune proprietà che torneranno utili più tardi:Proprietà 1. Sia Vk ∈ Rn×k la matrice costituita da V privata dell’ultima colonna,allora per ogni k vale la proprietà:

AVk = V H

Proprietà 2. H è per costruzione Hessenberg-superiore; siano ρ1, ρ2, . . . , ρk i suoiautovalori, questi sono chiamati valori di Ritz e rappresentano un’approssimazionedei primi k autovalori di A λ1, λ2, . . . , λk .

In maggiore dettaglio:1. Si sceglie un vettore casuale x, nella subroutine che scriveremo lo supponiamoin ingresso, lo normalizziamo calcolando x||x||2 . Salviamo x come primo vettore diKrylov nella prima colonna di V .2. Eseguiremo k iterazioni della seguente procedura, denotando con i l’iterazionecorrente.(a) Calcoliamo il prodotto Ax ottenendo il successivo vettore di Krylov daortonormalizzare.(b) Sottraiamo dal vettore ottenuto tutte le proiezioni ortogonali rispetto aiprecedenti vettori di Krylov, ottenendo così l’ortogonalizzazione di x . Perfare ciò calcoliamo:

Hli = V (:, l)T x l = 1, . . . , i x = x−i∑l=1 HliV (:, l)

In tale modo è possibile costruire anche la matrice H .(c) Eseguiamo la normalizzazione di x calcolando x||x||2 , salviamo il vettoreottenuto nella i+ 1-esima colonna di V e poniamo H(i+1)i = ||x||2.

6

Il procedimento sopra descritto comporta essenzialmente due svantaggi principali:anzitutto la numerica instabilità che porta ad una perdita di ortogonalizzazione de-rivante dal fenomeno di cancellazione alla fase 2.b. Per risolvere ciò o si utilizzanoopportune tecniche di riortogonalizzazione oppure, come faremo nel successivo algo-ritmo Arnoldi-Type, forme di ”restarting”.Altro problema, in fase 2.c, è la possibile terminazione anticipata (”breakdown”) del-l’algortimo: se l’esecuzione del prodotto Ax ci fa ottenere un vettore linearmente di-pendente rispetto ad altri vettori precedentemente inseriti nella base di Krylov, la pro-cedura di ortogonalizzazione porterà ad ottenere un vettore nullo e nella fase di nor-malizzazione otterremmo una divisione per 0. Fortunatamente, vista la conformazionedella matrice di Rank, tale eventualità non andrà a verificarsi.Nel nostro caso assumeremo A = PTα , si potrà sfruttare la subroutine creata alparagrafo precedente per effettuare prodotti PTα x con un dispendio ridotto.Vediamo di valutare il costo computazionale per iterazione: il prodotto PTα x costa comegià visto 4n + 2m + 1 operazioni, saranno inoltre necessari i prodotti scalari per ilcalcolo degli Hli al costo standard di 2n − 1, in operazioni per gli i distinti prodotti

HliV (:, l), kn operazioni per la differenza x = x−∑i

l=1 HliV (:, l) e infine 3n operazioniper la normalizzazione. In totale si hanno (10 + 2k )n+ 2m+ 1− k operazioni al casopessimo.Il codice della subroutine:

1 SUBROUTINE arnoldi(i,j,d,alpha ,n,m,x,V,H,iter ,matvec)23 IMPLICIT NONE45 ! Parametri formali.6 INTEGER , PARAMETER :: dp=KIND (0.d0)7 INTEGER :: iter8 INTEGER :: n, m, matvec9 INTEGER , DIMENSION (m) :: i, j

10 INTEGER , DIMENSION (n) :: d11 REAL(dp), DIMENSION (n,iter +1) :: V12 REAL(dp), DIMENSION (iter+1,iter) :: H13 REAL(dp), DIMENSION (n) :: x14 REAL(dp) :: alpha1516 ! Variabili d’ambiente17 INTEGER :: k, l1819 ! Normalizzazione del vettore x.20 x = x / NORM2(x)2122 V(:,1) = x23 H = 024 DO k = 1,iter25 CALL prodotto(i,j,d,m,n,x,alpha)26 matvec = matvec + 1;27 DO l = 1,k

7

28 H(l,k) = DOT_PRODUCT(V(:,l),x)29 x = x - H(l,k) * V(:,l)30 END DO31 H(k+1,k) = NORM2(x)32 IF (H(k+1,k) == 0) THEN33 WRITE (*,*) ’Breakdown al passo ’, k34 EXIT35 END IF36 x = x/H(k+1,k)37 V(:,k+1) = x38 END DO3940 END SUBROUTINEDa notare l’uso della variabile matvec che conta i prodotti matrice/vettore, comevedremo in seguito tale valore sarà indice del costo computazionale dell’intero algo-ritmo per il calcolo del Rank.Ricordo inoltre che la funzioni ”built-in” DOT_PRODUCT e NORM2 calcolano rispettiva-mente il prodotto scalare e la norma-2 di un vettore.

2.3 Algoritmo Arnoldi-Type per il calcolo del PageRank. (Golub-Greif, 2004)In questo paragrafo sfrutteremo le subroutine appena create per implementare unprogramma già completo per il calcolo del Rank che andremo nei paragrafi successiviad affinare.L’idea è quella di utilizzare l’iterazione di Arnoldi con ”restarting”: si fissa un numero

k << n,m di iterazioni ogni quante smorzare la procedura, sfrtuttare la matrice Hprodotta per l’approssimazione dell’1-autovettore (vedremo a breve dettagli su questafase) e utilizzare quanto ottenuto come partenza per successivi k passi di Arnoldi,ripetendo il tutto finchè il residuo tra due successive approssimazioni del Rank sia aldi sotto di una tolleranza fissata.L’approssimazione dell’autovettore avviene scegliendo tra i vettori dello spazio diKrylov Kk (A, x) quello più idoneo, ossia x ∈ Rn tale che soddisfi

||(A− I )x||2 = minu ∈ Kk (A, x)||u||2 = 1

||(A− I)u||2Si tratta di una variazione del problema lineare ai minimi quadrati, l’approccio origi-nale di Golub e Greif consiste, definita I ∈ R(k+1)×k come

I =

1 0 . . . 00 1 . . . 0... . . . ...0 0 . . . 10 0 . . . 0

nel calcolare la SVD della matrice H − I = UΣW T e ottenere poi x = VkW (:, k ).Una proprietà piuttosto vantaggiosa consente di calcolarci la norma del residuo senzaoperazioni aggiuntive:

8

Proposizione 1. Il criterio di fermata ||Ax− x||2 < ε è equivalente a σmin(H − I) < ε ,dove σmin(.) rappresenta il più piccolo valore singolare in modulo.

Dimostrazione: effettuando alcuni passaggi algebrici e sfruttando le proprietà diortogonalità,||Ax− x||2 = ||(A− I )x||2 = 1 min

||y||2=1 ||(A− I)Vky||2 = 2 min||y||2=1 ||V (H − I)y||2 =

= min||y||2=1 ||(H − I)y||2 = σmin(H − I)

Visto il fatto che la matrice Pα è stocastica (ossia somma dei valori sulle righeuguale a 1) e pertanto tale che la rispettiva norma-1 sia già 1, appare più precisoutilizzare la condizione di arresto ||PTα x − x||1 < ε anziché ||PTα x − x||2 < ε . Poichèquesto passaggio non è parte dell’idea originale di Golub e Greif rimanderemo l’usodella norma-1 come condizione d’arresto agli affinamenti successivi.Parliamo ora di costo computazionale complessivo: un’iterazione di Arnoldi-Typecomporta:• k passi di Arnoldi, al costo di al più (10 + k )n + 2m + 1 − k operazioni l’unocome già visto.• L’approssimazione dell’1-autovettore: O((k + 1)2k ) per la SVD (metodo Golub-Kahan) e n(2k − 1) operazioni per il prodotto VkW (:, k ).La scelta di k << m,n facilita di non poco la situazione rendendo asintoticamentetrascurabile il calcolo della SVD e permettendo di non oltrepassare la ”barriera” degli

O(m + n) per iterazione. Visto quanto ottenuto, possiamo assumere il numero deiprodotti PTα x effettuati come indice di confronto in termini di complessità tra duedifferenti applicazioni di Arnoldi-Type e persino tra Arnoldi-Type e un classico metododelle potenze su di una stessa rete.Veniamo ora alle questioni prettamente implementative: per il calcolo della SVDricorriamo alla subroutine DGESVD della libreria LAPACK e poichè quest’ultima con-tiene numerosi parametri, alcuni dei quali non propriamente utili al nostro scopo, altrinon di immediata lettura, sfrutteremo la seguente subroutine di interfaccia:

1 SUBROUTINE calcola_svd(m,n,A,D,U,VT)23 IMPLICIT NONE45 INTEGER , PARAMETER :: dp=kind (0.d0)6 INTEGER :: m, n, ldu , ldvt , info , &7 lwork , lda8 REAL(dp), DIMENSION(m,n) :: a(m,n), u(m,m), vt(n,n)9 REAL(dp), DIMENSION(min(m,n)) :: d

10 REAL(dp), DIMENSION (3*(m+n)) :: work

1Sfruttando la formula utilizzata per ricavarci x2Per la Proprietà 1 dell’iterazione di Arnoldi9

11 CHARACTER :: jobu , jobvt1213 jobu=’A’14 jobvt=’A’15 ldu=m16 ldvt=n17 lda=m18 lwork =3*(m+n)1920 CALL DGESVD( JOBU ,& ! U contiene i vettori singolari sinistri21 JOBVT ,& ! V contiene i vettori singolari destri22 M, N,& ! Dimensioni della matrice di lavoro23 A,& ! Matrice di lavoro24 LDA ,&25 D,& ! Il vettore dei valori singolari26 U,& ! la matrice dei v.s. sinistri27 LDU ,&28 VT ,& ! la matrice dei v.s. destri29 LDVT , WORK , LWORK , INFO )3031 END SUBROUTINE

Siamo pronti ad implementare l’intero algortimo Arnoldi-Type utilizzando tutte lesubroutines finora scritte. Ricordiamo le funzioni built-in del Fortran TRANSPOSE checalcola la trasposta di una matrice e MATMUL che esegue prodotti tra matrici; si èinoltre sfruttato il fatto che i valori singolari sono ordinati da DGESVD in manieradecrescente.1 PROGRAM PageRankAT23 IMPLICIT NONE45 INTEGER , PARAMETER :: dp=KIND (0.d0)6 INTEGER :: n, m, iter , k, matvec =07 INTEGER , DIMENSION (:), ALLOCATABLE :: i, j, d8 REAL(dp), DIMENSION (:,:), ALLOCATABLE :: V, H, ID, U, W9 REAL(dp), DIMENSION (:), ALLOCATABLE :: x, dg

10 REAL(dp) :: alpha =0.85, tol=10e-13, r1112 ! Scelta del numero di iterazioni di Arnoldi da effettuare per passo.13 WRITE (*,*) ’Quante it. di Arnoldi per passo?’14 READ (*,*) iter1516 ! Lettura dati e allocazione arrays.17 OPEN (UNIT=2,FILE=’rankmat.txt ’)18 READ (2,*) n19 READ (2,*) m20 ALLOCATE (i(m),j(m),d(n),x(n),V(n,iter+1),H(iter+1,iter))21 ALLOCATE(ID(iter+1,iter),dg(iter),U(iter+1,iter+1),W(iter ,iter))2223 ! Costruzione dei vettori i,j,d.

10

24 d = 025 DO k=1,m26 READ (2,*) i(k), j(k)27 d(i(k)) = d(i(k)) + 128 END DO2930 ! Costruzione della matrice pseudoidentica.31 ID = 032 DO k=1,iter33 ID(k,k) = 134 END DO353637 ! Scelta del vettore casuale.38 DO k=1,n39 CALL RANDOM_NUMBER(x(k))40 END DO4142 r = 143 DO WHILE (r > tol)44 CALL arnoldi(i,j,d,alpha ,n,m,x,V,H,iter ,matvec)45 CALL calcola_svd(iter+1,iter ,H-ID,dg,U,W)46 W = TRANSPOSE(W)47 x = MATMUL(V(:,:iter),W(:,iter))48 r = dg(iter)49 END DO5051 x = x / NORM2(x)5253 ! Scrittura dati.54 OPEN (UNIT=3,FILE=’rank ’)55 DO k=1,n56 WRITE (3,*) x(k)57 END DO5859 WRITE (*,*) ’Prodotti matrice -vettore svolti:’, matvec6061 END PROGRAM

2.4 Una procedura di estrapolazione ai valori di Ritz.Ci dedicheremo ora alla costruzione di un necessario passaggio volto a consentireun’accelerazione ulteriore della convergenza del vettore di Rank. Non tutti i vettoriiniziali per un’iterazione di Arnoldi risultano essere allo stesso modo ”buoni”: cer-cheremo di sfruttare gli autovalori ρ1, . . . , ρk della matrice H (chiamati valori di Ritz,vedi Proprietà 2) per individuare potenziali vettori iniziali per iterazioni di Arnoldisuccessive più profique.Denotiamo 1, λ2, λ3 come i primi tre autovalori in modulo della matrice PTα ∈ Rn×n,con x1, x2, x3 i rispettivi autovettori. Un’iterazione di Arnoldi con k = 3 saprà fornirci

11

la matrice H ∈ R3×3, dalla quale potremo calcolare agevolmente (H è già in formaHessenberg) i valori di Ritz ρ1, ρ2, ρ3.Sia x(k−1) ∈ Rn l’approssimazione del vettore di Rank derivante da un’istanza Arnoldi-Type, supponiamo di poter scrivere x(k−1) come combinazione lineare dei primi treautovettori di PTα :x(k−1) = x1 + α2x2 + α3x3 (5)Sfruttando la (5) posso ricavarmi:

x(k ) = PTα x(k−1) = PTα (x1 + α2x2 + α3x3) = PTα x1 + α2PTα x2 + α3PTα x3 == x1 + α2λ2x2 + α3λ3x3E ancora:x(k+1) = PTα x(k ) = PTα (x1 + α2λ2x2 + α3λ3x3) = PTα x1 + α2λ2PTα x2 + α3λ3PTα x3 == x1 + α2λ22x2 + α3λ23x3Da cui calcolo infine:

x(k+1)− (λ2 +λ3)x(k ) +λ2λ3x(k−1) = x1 +α2λ22x2 +α3λ23x3− (λ1 +λ2)(x1 +α2λ2x2 +α3λ3x3)++λ2λ3(x1 + α2x2 + α3x3) == x1 − λ2x1 − λ3x1 + λ2λ3x1 = x1(1 + λ2λ3 − λ3 − λ2) = x1(1− λ2)(1− λ3)Per cui:x1 = x(k+1) − (λ2 + λ3)x(k ) + λ2λ3x(k−1)(1− λ2)(1− λ3)Scelgo come vettore iniziale per una successiva iterazione di Arnoldi il seguente:

x = x(k+1) − (λ2 + λ3)x(k ) + λ2λ3x(k−1)||x(k+1) − (λ2 + λ3)x(k ) + λ2λ3x(k−1)|| (6)

Non avendo a disposizione i valori di λ2, λ3 è necessario sfruttare le approssimazionifornite dai valori di Ritz ρ2, ρ3 (vedi Proprietà 2) e riformulare la (6) nelle differenticasistiche. Prima di procedere è necessario dare la seguente:Definizione 2. Chiamo ”defective” un autovalore λ tale che µalg(λ) > µgeom(λ).Ossia nella nostra ottica ρ2, ρ3 sono ”defective” se ρ2 = ρ3 e i corrispettivi auto-vettori sono linearmente dipendenti.Osserviamo tutti i casi possibili.1. ρ2 e ρ3 sono ”non defective”(a) ρ2 e ρ3 sono reali, allora (6) diviene:

x = x(k+1) − (ρ2 + ρ3)x(k ) + ρ2ρ3x(k−1)||x(k+1) − (ρ2 + ρ3)x(k ) + ρ2ρ3x(k−1)|| (7)

(b) ρ2 e ρ3 sono complessi coniugati, allora otteniamo:x = x(k+1) − 2Re(ρ2)x(k ) + |ρ2|2x(k−1)||x(k+1) − 2Re(ρ2)x(k ) + |ρ2|2x(k−1)|| (8)

2. ρ2 e ρ3 sono ”defective”, posso sfruttare il fatto che α è esattamente il secondoautovalore in modulo di PTα e rinunciare all’uso di ρ2 e ρ3 evitando conseguentiproblemi di computazione, la (6) diviene:x = x(k ) − αx(k−1)1− α (9)

12

La procedura di estrapolazione sopra descritta comporta al massimo 2 prodotti PTα xper il calcolo di x(k ) e x(k+1), al solito costo di 4n+ 2m+ 1 operazioni l’uno, il calcolodegli autovalori e autovettori di H ∈ R3×3 a costo fisso e infine x con un dispendio dial più 5n− 2 operazioni: ancora una volta non superiamo gli O(m+ n). Riporteremoil codice riguardante questa parte nel paragrafo successivo poichè sono in gioco altrevariabili che necessitano opportuna introduzione.2.5 Algoritmo Arnoldi-Extrapolation per il calcolo del PageRank.Costruiamo un’ulteriore soluzione al problema del Rank definendo un algoritmo chesvolga le suddette istruzioni:1. Scegliendo un vettore iniziale, lo si normalizza e si eseguono maxit iterazioni delmetodo delle potenze: ci fermiamo in anticipo se si è già raggiunta la tolleranzafissata tol, in condizioni normali incrementiamo il contatore di iterazione soloquando il rapporto tra due successive variazioni relative in norma-1 è al di sopradi un valore β prefissato.2. Finchè la norma-1 del residuo rimane al di sopra di tol eseguiamo iterazioniArnoldi-Type, intermezzate da periodici affinamenti del vettore iniziale medianteprocedure di estrapolazione ai valori di Ritz.3. Riguardo alla periodicità delle procedure di estrapolazione, si fissa inizialmenteun intero l e si esegue estrapolazione alla fine di un’iterazione Arnoldi-Type se

matvec ≡ 0 mod l.4. Se matvec ≡ 0 mod l si eseguono al più maxit procedure di Ritz consecutivee ci fermiamo terminando l’algoritmo se il residuo è inferiore a tol, terminiamoanticipatamente la fase di estrapolazione se la norma-1 del vettore x ottenutoè inferiore ad un valore prefissato tolnorm ed incrementiamo il contatore diiterazioni ogni volta che il rapporto tra due successive variazioni relative innorma-1 è superiore a β .La tecnica presente consta di iterazioni Arnoldi-Type con k = 3, proprio perchè l’estra-polazione introdotta nel paragrafo 2.4 richiede esattamente 3 valori di Ritz: questoconsente un miglioramento evidente di Arnoldi-Extrapolation in termini di memoriaoccupata rispetto all’Arnoldi-Type classico che richiede necessariamente un valore kdipendente dalla dimensione di matrice PTα , sebbene estremamente più piccolo di es-sa. Se prima si doveva memorizzare una matrice V ∈ Rn×(k+1) e H ∈ R(k+1)×k , adessomemorizzeremo in ogni caso V ∈ Rn×4 e H ∈ R4×3.Come già anticipato, effettueremo la valutazione delle condizioni d’arresto in norma-1. In particolare, sulla fase 2 dell’elenco descritto sopra sfrutteremo la seguente:

Proposizione 2. Se x è il vettore ottenuto da una procedura Arnoldi-Type, possocalcolare

r1 = ||PTα x− x||1||x||1

senza effettuare prodotti PTα x aggiuntivi.

13

Dimostrazione: il tutto segue effettuando alcuni passaggi algebrici e sfruttando laProprietà 1.r1 = ||PTα x− x||1

||x||1 = ||PTα (VkW (:, k ))− VkW (:, k )||1||VkW (:, k )||1 = ||V (HW (:, k ))− VkW (:, k )||1

||VkW (:, k )||1A livello di complessità computazionale diciamo soltanto che tutte le fasi dell’algo-ritmo Arnoldi-Extrapolation rientrano nell’O(m+n) per iterazione, si tratta essenzial-mente di valutazioni già svolte nei paragrafi precedenti: ancora una volta possiamosfruttare il numero di prodotti PTα totali come metro di confronto, visto che sono ana-loghe le considerazioni fatte con quanto detto per l’Arnoldi-Type.La scelta migliore dei valori β , maxit, tolnorm, l è il risultato di considerazioni eu-ristiche che ci riserviamo di non effettuare: mi limito a riportare i settaggi ottimaliconsigliati degli stessi Wu e Wei.

β = α − 0.2, maxit = 6, tolnorm = 10−1, l = 4Riportiamo alcune subroutines necessarie all’implementazione dell’algoritmo. An-zitutto una procedura d’interfaccia che sfrutta la DHSEQR di LAPACK per il calcolo diautovalori (mediante una versione dell’algoritmo QR) e la DHSEIN per avere i rispettiviautovettori: tale subroutine fornisce i valori di Ritz e una variabile logica che vale

.TRUE. nel caso ”defective”, .FALSE. altrimenti.1 SUBROUTINE RitzValues(H,deg ,real1 ,imag1 ,real2 ,imag2)23 IMPLICIT NONE45 ! Parametri formali.6 INTEGER , PARAMETER :: dp=KIND (0.d0)7 INTEGER , PARAMETER :: dimen =38 REAL(dp), DIMENSION(dimen ,dimen) :: H9 REAL(dp) :: real1 , real2 , imag1 , imag2

10 LOGICAL :: deg1112 ! Variabili d’ambiente.13 CHARACTER :: job=’E’, compz=’N’, side=’R’, &14 eigsrc = ’N’, initv = ’N’15 INTEGER :: ilo=1, ihi=dimen , ldh=dimen , &16 ldz=dimen , lwork=dimen , info , &17 m=dimen , mm=dimen , ldvl=dimen , &18 ldvr=dimen19 REAL(dp), DIMENSION(dimen ,dimen) :: Z20 REAL(dp), DIMENSION(dimen) :: wr=0, wi=0, work21 REAL(dp), DIMENSION (( dimen +2)* dimen) :: work222 LOGICAL , DIMENSION(dimen) :: select = (/ .TRUE., .TRUE., &23 .TRUE. /)24 REAL(dp), DIMENSION(dimen ,dimen) :: VL=0, VR=025 INTEGER , DIMENSION(dimen) :: ifaill , ifailr26 INTEGER :: k2728 ! Calcolo autovalori di H.

14

29 CALL DHSEQR (job , & ! Trascuro il calcolo della f. di Schur.30 eigsrc , & ! Trascuro il calcolo dei vettori di Schur.31 dimen , & ! Dimensione della matrice H.32 ilo , &33 ihi , &34 H, & ! Matrice Hessenberg -superiore in input.35 ldh , &36 wr, & ! Parte reale degli autovalori.37 wi, & ! Parte immaginaria degli autovalori.38 Z, &39 ldz , &40 work , &41 lwork , &42 info )4344 ! Riordino autovalori per modulo e seleziono valori Ritz cercati.45 CALL riordina(wr,wi)46 real1 = wr(2);47 imag1 = wi(2);48 real2 = wr(3);49 imag2 = wi(3);505152 ! Controllo se i due valori di Ritz cercati sono degeneri.53 IF ((real1 /= real2).or.(imag1 /= imag2)) THEN54 deg = .FALSE. ! Caso non degenere.55 ELSE56 CALL DHSEIN (side , & ! Calcolo solo autovettori destri.57 eigsrc , &58 initv , &59 select , & ! Calcolo tutti gli autovettori.60 dimen , & ! Dimensione della matrice H.61 H, & ! Matrice Hessenberg -superiore in input.62 ldh , &63 wr, & ! Parte reale degli autovalori.64 wi, & ! Parte immaginaria degli autovalori.65 VL, &66 ldvl , &67 VR, & ! La matrice degli autovettori destri.68 ldvr , &69 mm, m, &70 work , ifaill , ifailr , info )7172 ! Controllo che i secondi due autovettori siano73 ! distinti (cond. non deg.)74 deg = .TRUE.75 DO k=1,dimen76 IF (VR(2,k) /= VR(3,k)) THEN77 deg = .FALSE.78 EXIT79 END IF

15

80 END DO81 END IF8283 END SUBROUTINEUna breve subroutine d’appoggio per ordinare gli autovalori decresecentemente in mo-dulo; si sfrutta la funzione MAXLOC che restituisce la posizione nell’array dell’occorrenzapiù grande.1 SUBROUTINE riordina(a,b)23 IMPLICIT NONE45 INTEGER , PARAMETER :: dp=KIND (0.d0), dimen=36 INTEGER :: k, mass7 REAL(dp), DIMENSION(dimen) :: a, b, a_ord=0, b_ord=0, modulus89 DO k=1,dimen

10 modulus(k) = SQRT(a(k)**2 + b(k)**2)11 END DO1213 DO k=1,dimen14 mass = MAXLOC(modulus ,1)15 a_ord(k) = a(mass)16 b_ord(k) = b(mass)17 modulus(mass) = 018 END DO1920 a = a_ord21 b = b_ord2223 END SUBROUTINE

Implementiamo ora l’estrapolazione ai valori di Ritz, così come l’abbiamo descrittanel paragrafo precedente, sfruttando i risultati prodotti dalla precedente subroutineRitzValues:

1 SUBROUTINE RitzExtrapolation(i,j,d,m,n,x,def ,real1 ,imag1 ,real2 , &2 imag2 ,l,matvec ,tol ,r,nor ,alpha ,rf)34 IMPLICIT NONE56 ! Parametri formali.7 INTEGER , PARAMETER :: dp=KIND (0.d0)8 INTEGER :: m, n, l, matvec , rf9 INTEGER , DIMENSION(n) :: d

10 INTEGER , DIMENSION(m) :: i, j11 REAL(dp), DIMENSION(n) :: x12 REAL(dp) :: real1 , real2 , imag1 , imag2 , tol , r, nor , alpha13 LOGICAL :: def1415 ! Variabili d’ambiente.

16

16 REAL(dp), DIMENSION(n) :: x_old1 , x_old21718 x_old1 = x19 CALL prodotto(i,j,d,m,n,x,alpha)20 matvec = matvec + 12122 ! Valuto variazione relativa.23 r = SUM(ABS(x - x_old1 )) / SUM(ABS(x_old1 ))2425 ! Qualora la variazione relativa sia inferiore a 10^-2 e sia soddisfatta26 ! la p e r i o d i c i t procedo con l’estrapolazione.27 IF ((r > tol) .and. (r < 10.e-2) .and. (MOD(matvec ,l) == 0)) THEN2829 ! Caso autovalori ’non -defective ’.30 IF (def .eqv. .FALSE.) THEN3132 ! Autovalori reali.33 IF ((imag1 == 0) .and. (imag2 == 0)) THEN34 x_old2 = x_old135 x_old1 = x36 CALL prodotto(i,j,d,m,n,x,alpha)37 matvec = matvec + 138 x = x - (real1 + real2) * x_old1 + real1 * &39 real2 * x_old24041 ! Autovalori complessi coniugati.42 ELSE43 x_old2 = x_old144 x_old1 = x45 CALL prodotto(i,j,d,m,n,x,alpha)46 matvec = matvec + 147 x = x - 2 * real1 * x_old1 + (real1 **2 + &48 imag1 **2) * x_old249 END IF5051 ! Caso autovalori ’defective ’.52 ELSE53 x = x - alpha * x_old154 END IF5556 ! Normalizzo vettore ottenuto.57 nor = SUM(ABS(x));58 x = x / nor5960 rf = rf + 16162 END IF6364 END SUBROUTINE

17

Ed infine il programma che implementa l’algoritmo Arnoldi-Extrapolation:1 PROGRAM PageRankAE23 IMPLICIT NONE456 INTEGER , PARAMETER :: dp=KIND (0.d0), iter=3, &7 period =48 REAL(dp), PARAMETER :: alpha =0.859 INTEGER :: n, m, k, matvec=0, maxit=6, &

10 restart , rf11 INTEGER , DIMENSION (:), ALLOCATABLE :: i, j, d12 REAL(dp), DIMENSION (:,:), ALLOCATABLE :: V, H, ID, U, W13 REAL(dp), DIMENSION (:), ALLOCATABLE :: x, y, dg14 REAL(dp) :: tol=10e-13, r, r_old , &15 beta=alpha -0.216 REAL(dp) :: r1, i1, r2, i2,17 tolnorm =10e-1, nor18 LOGICAL :: deg1920 ! Lettura dati e allocazione arrays.21 OPEN (UNIT=2,FILE=’rankmat.txt ’)22 READ (2,*) n23 READ (2,*) m24 ALLOCATE (i(m),j(m),d(n),x(n),V(n,iter+1),H(iter+1,iter))25 ALLOCATE(ID(iter+1,iter),dg(iter),U(iter+1,iter+1),W(iter ,iter))2627 ! Costruzione dei vettori i,j,d.28 d = 029 DO k=1,m30 READ (2,*) i(k), j(k)31 d(i(k)) = d(i(k)) + 132 END DO3334 ! Costruzione della matrice pseudoidentica.35 ID = 036 DO k=1,iter37 ID(k,k) = 138 END DO3940 ! Scelta del vettore casuale.41 DO k=1,n42 CALL RANDOM_NUMBER(x(k))43 END DO4445 ! Approssimazione ’grossolana ’ del vettore iniziale46 ! mediante metodo delle potenze.47 r = 148 r_old = r49 restart = 050 rf = 0 ! Conta i raffinamenti sul vettore iniziale.

18

51 DO WHILE (( restart < maxit) .and. (r > tol))52 y = x53 CALL prodotto(i,j,d,m,n,x,alpha)54 matvec = matvec + 155 r = SUM(ABS(x - y)) / SUM(ABS(y))56 x = x / SUM(ABS(x))57 IF (r/r_old > beta) THEN58 restart = restart + 159 END IF60 rf = rf + 161 r_old = r62 END DO6364 ! Proseguo con l’Arnoldi -type , operando raffinamenti periodici65 ! mediante estrapolazione.66 DO WHILE (r > tol)67 CALL arnoldi(i,j,d,alpha ,n,m,x,V,H,iter ,matvec)68 CALL calcola_svd(iter+1,iter ,H-ID,dg,U,W)69 W = TRANSPOSE(W)70 y = MATMUL(V(:,:iter),W(:,iter))71 x = MATMUL(V,MATMUL(H,W(:,iter )))72 r = SUM(ABS(x - y)) / SUM(ABS(y))7374 ! Avvio procedura di estrapolazione.75 x = x / SUM(ABS(x))76 restart = 077 CALL RitzValues(H(:iter ,:),deg ,r1,i1,r2,i2)78 r_old = r79 nor = 180 DO WHILE ((r > tol) .and. (restart < maxit) .and. (nor >= tolnorm ))81 CALL RitzExtrapolation(i,j,d,m,n,x,deg ,r1,i1,r2,i2, &82 period ,matvec ,tol ,r,nor ,alpha ,rf)83 IF (r / r_old > beta) THEN84 restart = restart + 185 END IF86 r_old = r87 END DO88 END DO8990 ! Scrittura dati.91 OPEN (UNIT=3,FILE=’rank ’)92 DO k=1,n93 WRITE (3,*) x(k)94 END DO9596 WRITE (*,*) ’Prodotti matrice -vettore svolti:’, matvec97 WRITE (*,*) ’Raffinamenti del vettore iniziale di Arnoldi effettuati:’, rf9899 END PROGRAM

19

2.6 Sperimentazioni numeriche.Siamo pronti a testare gli algoritmi sinora implementati su dati reali: abbiamo am-piamente visto che non vi sono grandi differenze in termini asintotici nella complessitàper la singola iterazione, per poter esaminare le prestazioni totali è pertanto neces-sario stabilire quale converga più velocemente su una stessa matrice input, ossia perquanto già detto quale comporta un minor numero di prodotti PTα x.Poichè sfruttare matrici generate casualmente comporta un’eccessiva sparsità, sen-za aree di maggiore densità di 1 come avviene assai spesso nella realtà, ciò nondifferenzia particolarmente i nostri algoritmi in termini prestazionali: noi useremoinvece una matrice di dimensione 103 × 103 costruita a partire dal nodo di retehttp://www.unipi.it, i cui dettagli sono illustrati in appendice.È perfettamente ovvio il fatto che con matrici di maggiore grandezza avremmo avutorisultati ancora più significativi, tuttavia il processo di costruzione della unipi1000(così ho denotato la matrice) ha richiesto almeno 5/6 ore! In generale, la tecnicautilizzata per ricavarci matrici di adiacenza da internet che descriveremo è veramentemolto lenta.Ciò che si è fatto consiste essenzialmente nell’esaminare gli algoritmi metodo poten-ze classico, Arnoldi-Type e Arnoldi-Extrapolation sui valori distinti di α nell’insieme{0.85, 0.90, 0.95, 0.99} e per ogni valore scelto si è eseguito ciascun metodo tenendoconto dei residui in norma-1 tutte le volte che si è effettuato un prodotto PTα x. In talemodo è stato possibile costruire dei grafici volti a mostrare l’andamento della riduzio-ne dell’errore all’aumentare dei prodotti matrice/vettore per ogni casistica possibile: irisultati sono riportati nelle figure successive.Per quanto riguarda i settaggi dei vari metodi, si sono impostati per l’Arnoldi-Extrapolationi valori elencati in precedenza, mentre per avere un confronto corretto con l’Arnoldi-Type si sono impostate 3 iterazioni di Arnoldi per passo su quest’ultimo.Vediamo di commentare i risultati: per tutti i valori di α scelti Arnoldi-Extrapolationriesce ad affermarsi come soluzione migliore, seguita de Arnoldi-Type che consentegià risultati nettamente migliori del metodo delle potenze. Ciò è esattemente quan-to potevamo aspettarci: le periodiche procedure di estrapolazione dei vettori (visibilidalla presenza di alcune irregolarità sui grafici, a volte persiono aree non monotone)forniscono input che portano a convergenze più rapide mediante iterazioni di Arnoldi.La motvazione che ci ha portato alla ricerca di strade alternative a quella del metododelle potenze, già buona per α = 0.85, è però la perdita di prestazioni al crescere diα ↑ 1: osservando i grafici ci rendiamo sia conto di quanto il numero di prodotti PTα xcresca nel caso potenze, sia quanto le nostre altre due soluzioni abbiano un compor-tamento migliore.Man mano che α cresce i prodotti necessari alla convergenza aumentano anche neicasi Arnoldi-Type e Arnoldi-Extrapolation, ma tale aumento è nettamente minore ri-spetto all’iterazione delle potenze e ancora meglio, il divario tra Arnoldi-Extrapolatione Arnoldi-Type tende ad aumentare con α . Scegliamo dunque l’Arnoldi-Extrapolationcome metodo ”sfidante” contro ciò che andremo a sviluppare nelle pagine successive.

20

21

Figura 2: PageRank della matrice unipi1000: sulle ascisse il numero dei prodottiPTα x per vari α , sulle ordinate i corrispondenti valori dell’errore in norma-1.

22

3 L’approccio Rational Extrapolation (Brezinski-Zaglia,2008)

Vogliamo adesso scegliere una strada del tutto differente per il raggiungimento delmedesimo risultato: data la nostra solita matrice PTα ∈ Rn×n costruiamo i vettori diRank sfruttando il metodo delle potenze rα1, . . . , rαd per diversi valori di α , costruireuna funzione p : (0, 1)→ Rn tale che p(α) = rα mediante tecniche di interpolazione ericavarci successivamente il vettore di Rank per α vicino a 1 semplicemente calcolan-doci p(α). Le tecniche presentate in questa sezione differiscono nella forma che deveassumere p e quindi dalla tecnica di interpolazione da intraprendere.3.1 Calcolo simultaneo dei vettori di Rank.Il fatto stesso che sono necessari i valori di Rank per svariati α prima di poter effet-tuare l’interpolazione necessaria a ricavarci p potrebbe farci sostenere l’inefficienzadell’algrotimo che stiamo per presentare anche nei confronti del più ingenuo metododelle potenze: presentiamo pertanto un accorgimento che ci consente di effettuare ilcalcolo simultaneo di svariati vettori di Rank con un lieve overload di costo rispetto alnormale calcolo di rαmax mediante iterazione delle potenze, dove αmax = maxi=1,...,d αi.Ciò significa che non devo effettuare d metodi delle potenze diversi, ma con una solaiterazione posso ricavarmi tutti i vettori cercati: sfrutto infattiProposizione 3. Sia α 6= α , vale la seguente relazione ricorrente, dove x rappresentail vettore casuale di inizio iterazione:

r(0)α = x

r(k+1)α = r(k )

α − αk+1αk+1 (r(k+1)

α − r(k )α )

Dimostrazione: per semplicità di notazione pongo A := PT , si può ricavare ilseguente fatto (A− I)Akx = 1αk+1 (r(k+1)

α − r(k )α ) k = 0, 1, . . .Poichè il primo termine della precedente uguaglianza non dipende da α , posso scri-vere: 1

αk+1 (rk+1α − r(k )

α ) = 1α (k+1) (r(k+1)

α − r(k )α )dalla quale con ovvi passaggi algebrici, ricavo:

r(k+1)α = r(k )

α −αk+1αk+1 (r(k+1)

α − r(k )α )

Analogamente alla normale iterazione delle potenze risulta corretto porre r(0)α = x,dove x è il medesimo vettore casuale scelto per il caso α .

Stabiliamo quale sia effettivamente questo overload in costo computazionale periterazione svolta: il calcolo di r(k+1)α − r(k )

α costa n operazioni, così come αk+1 e αk+1.Abbiamo un’ulteriore operazione per αk+1αk+1 , n operazioni per il prodotto e altrettante

23

per la differenza finale: in totale (5n+ 1)(d− 1) operazioni aggiuntive per iterazione,il che (visto che d � n,m) lascia il dispendio per passo sulla linea degli O(n + m)non aggiungendo eccessivo carico rispetto ad un singolo calcolo del vettore di Rankmediante iterazione delle potenze (considerando che nella stragrande maggioranzadei casi si ha comunque m > n).3.2 Una procedura di interpolazione con base di Lagrange.Sfruttando i vettori di Rank per d differenti valori di α (nodi di interpolazione), vogliamoindividuare una funzione p della forma:

p(α) = Pd(α)Qd(α) (10)

dove Pd e Qd sono polinomi di grado d − 1 < n− 1, Pd a coefficienti vettoriali e Qda coefficienti scalari.Scritto per semplicità pi := rαi , pongo come ulteriore condizione:Pd(αi) = Qd(αi)pi i = 1, . . . , d (11)

Prima di procedere con gli sviluppi algebrici diamo la seguenteDefinizione 3. chiamo base di Lagrange Ld = {L1, . . . , Ld} con

Li(α) = d∏j = 1j 6= i

α − αjαi − αj

Risultano evidenti i due fatti seguenti:• Li(αh) = 0 per ogni h 6= i, Li(αi) = 1.• Se f (x) = ∑d

i=1 aiLi(x), ponendo yh = f (xh) per ogni nodo xh e imponendosu tutti i nodi yh = ∑di=1 aiLi(xh) si ottiene il sistema banale Ia = y, dove

a = [a1 . . . ad]T e y = [y1 . . . yd]T . Si ha quindi che ai = yi,∀i = 1, . . . , d senzache sia necessario alcun calcolo per avere i coefficienti di interpolazione.Tornando alla nostre funzioni Pd e Qd, vogliamo scriverle come combinazione linearedi valori della base di Lagrange:

Pd(α) = d∑i=1 aiLi(α)

Qd(α) = d∑i=1 biLi(α)

Ed applicando quanto osservato prima:Pd(α) = d∑

i=1 Pd(αi)Li(α)24

Qd(α) = d∑i=1 Qd(αi)Li(α)

Sfruttando infine la condizione imposta (11):Pd(α) = d∑

i=1 Li(α)Qd(αi)pi (12)Supponiamo di conoscere per un α∗ 6= αi ∀i = 1, . . . , d il corrispettivo vettore diRank rα∗ ; utilizzando la (10) e la (12) scrivo

p(α∗) = Pd(α∗)Qd(α∗) = ∑d

i=1 Li(α∗)Qd(αi)piQd(α∗) = d∑

i=1 Li(α∗)Qd(αi)Qd(α∗)pi =d∑i=1 Li(α∗)ci(α∗)pi (13)

dove ci(α∗) rappresenta ovviamente il rapporto Qd(αi)Qd(α∗) . Considero ora d vettori linear-mente indipendenti s1, . . . , sd: per ogni j = 1, . . . , d accade

〈p(α∗), sj〉 = 〈rα∗, sj〉e quanto scritto è equivalente a (sfruttando la (13)):d∑i=1 Li(α∗)ci(α∗)〈pi, sj〉 = 〈rα∗, sj〉 j = 1, . . . , d (14)

La (14) opportunamente riscritta rappresenta un sistema lineare nelle incognite ui :=Li(α∗)ci(α∗), definisco pertanto:

Π = p1 p2 . . . pd

S = s1 s2 . . . sd

L(α) =L1(α) 0. . .0 Ld(α)

c(α∗) =

c1(α∗)...cd(α∗)

u(α∗) =L1(α∗)c1(α∗)...Ld(α∗)cd(α∗)

= L(α∗)c(α∗)Posso riscrivere la (14) come:

STΠu(α∗) = ST rα∗ (15)Risolvendo il sistema (15) ricavo facilmente c(α∗) = L−1(α∗)u(α∗): resta da far vederecome posso sfruttare proprio questo valore c(α∗) per rappresentare la funzione p.Effettando i passaggi:

p(α) = Pd(α)Qd(α) = ∑d

i=1 Li(α)Qd(αi)pi∑di=1 Li(α)Qd(αi)

25

Dividendo numeratore e denominatore per la stessa quantità Qd(α∗) ottengo infine:p(α) = ∑d

i=1 Li(α)ci(α∗)pi∑di=1 Li(α)ci(α∗) (16)

Visti i dati a disposizione, mi piacerebbe riscrivere la (16) sottoforma matriciale. Sfruttole considerazioni seguenti:• La quantità∑d

i=1 Li(α)ci(α∗) può essere evidentemente scritta come 〈L(α)c(α∗), e〉.• Vediamo ora la quantità al numeratore ∑d

i=1 Li(α)ci(α∗)pi: vogliamo che ciascunpi, ossia ciascuna colonna della matrice Π , sia moltiplicata per i suoi corrispettiviLi(α) e ciò è dato dal prodotto ΠL(α). Infine è necessario la somma delle colonneottenute, ciascuna moltiplicata per il suo ci(α∗): visto che un vettore somma èdato dalla somma delle sue componenti e su ciascuna dobbiamo effettuare lacombinazione lineare con i membri di c(α∗) pare evidente che il tutto sia ugualea ΠL(α)c(α∗)Ho finalmente ottenuto la formula di estrapolazione, valida per arbitrari α nel range(0, 1).

p(α) = ΠL(α)c(α∗)〈L(α)c(α∗), e〉 (17)

Riassumendo le fasi dell’algortimo:1. Si scelgono d nodi α1, . . . , αd e un ulteriore valore α∗ nel range (0, 1).2. Si calcolano i rispettivi vettori di Rank rα1, . . . , rαd e rα∗ sfruttando l’iterazionedelle potenze con l’accorgimento descritto al paragrafo 3.1.3. Si scelgono d vettori linearmente indipendenti s1, . . . , sd: per comodità si puòsupporre si = rαi , si ottiene perciò S = Π .4. Si costruiscono le matrici Π , L(α) e L(α∗).5. Si risolve il sistema lineare:ΠTΠu(α∗) = ΠT rα∗

6. Si calcola c(α∗) = L−1(α∗)u(α∗), notare che L−1(α∗) è diagonale.7. Si sfrutta la (17) per estrapolare il PageRank per qualsivoglia valore di α .Visioniamo i costi computazionali: la fase 2 costa come già visto O(m + n) periterazione del metodo delle potenze, la scelta dei vettori linearmente indipendenti

si non ha evidentemente alcun costo aggiuntivo. Per le matrici L(α) e L(α∗) sononecessari 2d calcoli dei valori delle basi di Lagrange al costo di 3(d − 1) + (d − 2)operazioni l’uno: in totale 8d2 − 10d operazioni, un valore costante visto che d èfissato e indipendente dalla dimensione di matrice. Abbiamo inoltre un solo prodottoΠTΠ al costo di 2nd2 − d2, ΠT rα∗ al costo di 2nd − d e la soluzione di un sistemalineare quadrato al costo standard di O(d3). Il calcolo di c(α∗) costa d operazioni,

26

mentre l’estrapolazione finale del vettore di Rank cercato costa 2d− 1 operazioni peril denominatore e 3nd− 1 per il numeratore.Visto il fatto che dopo la fase di calcolo dei Rank sui nodi si esegue sempre unnumero prefissato di step e che questi costano al più O(n), non trascureremo unnumero elevato di operazioni considerando solo il costo delle iterazioni delle potenze.In altre parole la nostra estrapolazione non costerà troppo più del calcolo degli rαi epotremo ancora una volta considerare i prodotti PTα x come indice di confronto, sebbenesia stavolta meno preciso. In altre parole, se il nostro algoritmo di interpolazioneimpiegherà più prodotti rαi di quanti ne impieghi un Arnoldi-Extrapolation, non saràcertamente più conveniente di quest’ultimo! Rimandiamo ulteriori considerazioni sulcosto computazionale nella parte dedicata al confronto finale tra i due approcci seguiti.Siamo pronti a mostrare il codice Fortran: inseriamo anzitutto una subroutine d’in-terfaccia che sfrutta la DGESV di LAPACK per la soluzione di sistemi lineari mediantefattorizzazione LU.

1 SUBROUTINE sys_solve(A,n,b)23 IMPLICIT NONE45 ! Parametri formali.6 INTEGER , PARAMETER :: dp=KIND (0.d0)7 INTEGER :: n8 REAL(dp), DIMENSION(n,n) :: A9 REAL(dp), DIMENSION(n) :: b

1011 ! Variabili d’ambiente.12 REAL(dp), DIMENSION(n,n) :: M13 INTEGER :: nhrs=1, k, info14 INTEGER , DIMENSION(n) :: ipiv151617 ! Costruzione dell ’array ipiv (non utilizzato ).18 DO k=1,n19 ipiv(k) = k20 END DO2122 M = A;2324 CALL DGESV( n, & ! Dim. di M25 nhrs , & ! Colonne termine noto.26 M, & ! Matrice dei coeff.27 n, &28 ipiv , & ! Permutazioni della PLU.29 b, & ! IN: vettore term. noti. OUT: soluzione.30 n, &31 info )3233 END SUBROUTINE

27

Il codice del programma: si è utilizzato un array per memorizzare i nodi (c_list),supponendo come prerequisito che questo sia sempre ordinato. La dimensione di talearray è memorizzata nella variabile nodi, non comprensiva del nodo extra necessarioall’algoritmo.1 PROGRAM PageRankEX23 IMPLICIT NONE456 INTEGER , PARAMETER :: dp=KIND (0.d0), nodi=77 REAL(dp), PARAMETER :: alpha =0.858 INTEGER :: n, m, k, matvec=0, &9 maxit =5000, it

10 INTEGER , DIMENSION (:), ALLOCATABLE :: i, j, d11 REAL(dp), DIMENSION (:,:), ALLOCATABLE :: H, L12 REAL(dp), DIMENSION (:), ALLOCATABLE :: x, y, u, a, x_star13 REAL(dp), DIMENSION (nodi +1) :: c_list14 REAL(dp) :: tol=10e-13, r, prod1516 ! REQUIRES: c_list array ordinato e l’ultimo elemento c*.17 c_list = (/ 0.80, 0.805, 0.81, 0.815, 0.82, 0.825, 0.83, 0.835/)1819 ! Lettura dati e allocazione arrays.20 OPEN (UNIT=2,FILE=’rankmat.txt ’)21 READ (2,*) n22 READ (2,*) m23 ALLOCATE (i(m),j(m),d(n),x(n),y(n),x_star(n),u(nodi),a(nodi), &24 H(n,nodi),L(nodi ,nodi))2526 ! Costruzione dei vettori i,j,d.27 d = 028 DO k=1,m29 READ (2,*) i(k), j(k)30 d(i(k)) = d(i(k)) + 131 END DO3233 ! Scelta del vettore casuale e normalizzazione.34 DO k=1,n35 CALL RANDOM_NUMBER(x(k))36 END DO37 x = x / SUM(ABS(x))3839 ! Riempimento della matrice H.40 DO k = 1,nodi41 H(:,k) = x42 END DO4344 ! Costruzione dei vettori di rank sui nodi di interpolazione.45 DO it = 1,maxit46 y = x47 CALL prodotto(i,j,d,m,n,x,c_list(nodi +1))

28

48 matvec = matvec + 149 DO k = 1,nodi50 H(:,k) = H(:,k) + (c_list(k)** matvec )/ &51 (c_list(nodi +1)** matvec) * (x - y)52 END DO53 r = SUM(ABS(x-y))54 x = x / SUM(ABS(x))55 IF (r < tol) THEN56 EXIT57 END IF58 END DO59 x_star = x6061 ! Ricavo il vettore u.62 u = MATMUL(TRANSPOSE(H),x_star)63 CALL sys_solve(MATMUL(TRANSPOSE(H),H),nodi ,u);6465 ! Calcolo il valore degli elementi della base di Lagrange in c*.66 L = 067 DO it=1,nodi68 prod = 169 DO k=1,nodi70 IF (k /= it) THEN71 prod = prod * (c_list(nodi +1) - c_list(k)) / &72 (c_list(it) - c_list(k))73 END IF74 END DO75 L(it,it) = 1/prod76 END DO7778 ! Ricavo il vettore a.79 a = MATMUL(L,u)8081 ! Calcolo il valore degli elementi della base di Lagrange in alpha.82 L = 083 DO it=1,nodi84 prod = 185 DO k=1,nodi86 IF (k /= it) THEN87 prod = prod * (alpha - c_list(k)) / &88 (c_list(it) - c_list(k))89 END IF90 END DO91 L(it,it) = prod92 END DO9394 ! Calcolo il vettore di rank.95 x = MATMUL(MATMUL(H,L),a) / SUM(MATMUL(L,a))9697 ! Scrittura dati.98 OPEN (UNIT=3,FILE=’rank ’)

29

99 DO k=1,n100 WRITE (3,*) x(k)101 END DO102103 WRITE (*,*) ’Prodotti matrice -vettore svolti:’, matvec104105 END PROGRAM

3.3 Una procedura d’interpolazione più semplice.Vogliamo determinare una funzione p(α) della forma:p(α) = y + 1− α1− αλz (18)

Per ricavare p si utilizzeranno soltanto 3 nodi. Denotati ancora una volta pi = rαi ,vale la condizione d’interpolazione seguente:pi = y + 1− αi1− αiλz, i = 1, 2, 3 (19)

Scrivo la differenza p2−p1 sfruttando la (13): si ottiene una forma non dipendente dalvettore y.p2 − p1 = y + 1− α21− α2λz−

(y + 1− α11− α1λz

) = (1− α1λ)(1− α2)− (1− α2λ)(1− α1)(1− α1λ)(1− α2λ) z == 1− α2 − α1λ+ α1α2λ− 1 + α1 + α2λ− α1α2λ(1− α1λ)(1− α2λ) z = (1− λ)(α1 − α2)(1− α1λ)(1− α2λ)zPossiamo subito ricavare una formula per z:

z = (1− α1λ)(1− α2λ)(1− λ)(α1 − α2) (p2 − p1) (20)Restano da individuare il valore λ e il vettore y: sia pertanto q ∈ Rn tale che si abbia〈p2 − p1, q〉 6= 0 e 〈p3 − p1, q〉 6= 0, sia inoltre r123 così definitor123 = 〈p2 − p1, q〉

〈p3 − p1, q〉 = (1−λ)(α1−α2)(1−α1λ)(1−α2λ) ∑nh=1 zhqh(1−λ)(α1−α3)(1−α1λ)(1−α3λ) ∑nh=1 zhqh = (α1 − α2)(1− λ)(1− α1λ)(1− α2λ) (1− α1λ)(1− α3λ)(α1 − α3)(1− λ) =

= α1 − α2α1 − α3

(1− α3λ)(1− α2λ)Da quanto scritto sopra ricavo il valore λ:r123 = α1 − α2

α1 − α3(1− α3λ)(1− α2λ) ⇒ λ = r123(α1 − α3)− (α1 − α2)

α2r123(α1 − α3)− α3(α1 − α2) (21)Il vettore y è invece facilmente ricavabile dalla (19):

y = p1 − 1− α11− α1λz (22)Diamo un ordine alle fasi:

30

1. Si stabiliscono i tre nodi dell’interpolazione α1, α2, α3 e si calcolano i pi utiliz-zando quanto descritto al paragrafo 3.1.2. Si calcola r123 = 〈p2−p1,q〉

〈p3−p1,q〉 , scelto per esempio q come un vettore casuale norma-lizzato.3. Si sfrutta la (21) per calcolare λ.4. Si sfrutta la (20) per calcolare z.5. Si sfrutta la (22) per calcolare y.6. Possiamo estrapolare il PageRank per ogni valore di α usando la (18).Una breve riflessione sulla complessità: il punto (1) costa come prima O(m+n) periterazione, il punto (2) 8n−1 operazioni, il punto (3) 12 operazioni aritmetiche, il punto(4) 2n+ 9, il punto (5) 2n+ 4 e infine il punto (6) 2n+ 4 per ciascuna estrapolazionedesiderata. Valgono dunque le stesse considerazioni fatte al paragrafo precedente:possiamo ancora una volta sfruttare matvec come un blando indice di complessità.Il codice Fortran:

1 PROGRAM PageRankSimpleEX23 IMPLICIT NONE456 INTEGER , PARAMETER :: dp=KIND (0.d0), nodi=37 REAL(dp), PARAMETER :: alpha =0.858 INTEGER :: n, m, k, matvec=0, &9 maxit =5000, it

10 INTEGER , DIMENSION (:), ALLOCATABLE :: i, j, d11 REAL(dp), DIMENSION (:), ALLOCATABLE :: p1, p2, p3, q12 REAL(dp), DIMENSION (:), ALLOCATABLE :: x, y, z13 REAL(dp), DIMENSION (nodi) :: c_list14 REAL(dp) :: tol=10e-13, &15 lambda , r_123 , r1617 ! REQUIRES: c_list array ordinato.18 c_list = (/ 0.70, 0.72, 0.75 /)1920 ! Lettura dati e allocazione arrays.21 OPEN (UNIT=2,FILE=’rankmat.txt ’)22 READ (2,*) n23 READ (2,*) m24 ALLOCATE (i(m),j(m),d(n),x(n),y(n),z(n),p1(n),p2(n),p3(n),q(n))2526 ! Costruzione dei vettori i,j,d.27 d = 028 DO k=1,m29 READ (2,*) i(k), j(k)30 d(i(k)) = d(i(k)) + 1

31

31 END DO3233 ! Scelta del vettore casuale x e normalizzazione.34 DO k=1,n35 CALL RANDOM_NUMBER(x(k))36 END DO37 x = x / SUM(ABS(x))3839 ! Scelta del vettore casuale q.40 DO k=1,n41 CALL RANDOM_NUMBER(q(k))42 END DO4344 ! Riempimento degli arrays p1, p2 e p3.45 p1 = x46 p2 = x47 p3 = x4849 ! Costruzione dei vettori di rank sui nodi di interpolazione.50 DO it = 1,maxit51 y = x52 CALL prodotto(i,j,d,m,n,x,c_list(nodi))53 matvec = matvec + 154 p1 = p1 + (c_list (1)** matvec )/( c_list(nodi )** matvec) * (x - y)55 p2 = p2 + (c_list (2)** matvec )/( c_list(nodi )** matvec) * (x - y)56 r = SUM(ABS(x-y))57 x = x / SUM(ABS(x))58 IF (r < tol) THEN59 EXIT60 END IF61 END DO62 p3 = x6364 ! Calcolo approssimazione del secondo autovalore in modulo.65 r_123 = DOT_PRODUCT(p2-p3,q) / DOT_PRODUCT(p1-p3 ,q)66 lambda = (r_123 * (c_list (3) - c_list (1)) - (c_list (3) - c_list (2))) / &67 (c_list (2) * r_123 * (c_list (3) - c_list (1)) - c_list (1) * &68 (c_list (3) - c_list (2)))6970 ! Calcolo approssimazione del multiplo del secondo autovettore.71 z = ((1 - c_list (2) * lambda) * (1 - c_list (3) * lambda )) / &72 (( c_list (3) - c_list (2)) * (1 - lambda )) * &73 (p2 - p3)7475 ! Calcolo vettore y.76 y = p2 - ((1 - c_list (2)) / (1 - c_list (2) * lambda )) * z7778 ! Calcolo vettore di rank , ossia p(alpha).79 x = y + (1 - alpha) * (1 / 1 - alpha * lambda) * z8081 ! Scrittura dati.

32

82 OPEN (UNIT=3,FILE=’rank ’)83 DO k=1,n84 WRITE (3,*) x(k)85 END DO8687 WRITE (*,*) ’Prodotti matrice -vettore svolti:’, matvec8889 END PROGRAM

3.4 Interpolazione mediante minimizzazione del residuo.Un ulteriore modo di parametrizzare la funzione p(α) consiste nel considerare lacombinazione convessa dei nodi pi, ossia una scrittura nella forma:p(α) = γ1p1 + γ2p2 + · · ·+ γdpd tale che γ1 + · · ·+ γd = 1Ci limitiamo al caso d = 2 ottenendo perciò una funzione di estrapolazione di questotipo

pγ(α) = (1− γ)p1 + γp2 (23)Individueremo quel valore γ che minimizzi la norma del residuo, ossia fissato α :||PTα pγ(α)− pγ(α)|| = min

γ∈R||PTα pγ(α)− pγ(α)||

Effettuando alcuni passaggi algebrici:PTα pγ(α)−pγ(α) = (1−γ)PTα p1+γPTα p2−(1−γ)p1−γp2 = PTα p1−γPTα p1+γPTα p2−p1+γp1−γp2 =

= PTα p1 − p1 + γ [PTα (p2 − p1)− (p2 − p1)]Da cui, effettuando lo sviluppo al quadrato:||PTα pγ(α)− pγ(α)||2 = ||PTα p1 − p1||2 + 2γ〈PTα p1 − p1, PTα (p2 − p1)− (p2 − p1)〉++γ2||PTα (p2 − p1)− (p2 − p1)||Infine, procedo minimizzando il secondo termine.

f (γ) := ||PTα p1−p1||2+2γ〈PTα p1−p1, PTα (p2−p1)−(p2−p1)〉+γ2||PTα (p2−p1)−(p2−p1)||2f ′(γ) = 2〈PTα p1 − p1, PTα (p2 − p1)− (p2 − p1)〉+ 2γ||PTα (p2 − p1)− (p2 − p1)||2

f (γ) = 0 ⇔ γ = −〈PTα p1 − p1, PTα (p2 − p1)− (p2 − p1)〉||PTα (p2 − p1)− (p2 − p1)||2 (24)

Il nostro algortimo di interpolazione mediante minimizzazione del residiuo consta deiseguenti passi:1. Scelgo i due arbitrari nodi α1, α2 e calcolo i rispettivi p1, p2 sfruttando comesempre le proprietà di calcolo simultaneo mediante iterazione delle potenze(paragrafo 3.1).2. Calcolo γ seguendo la (24).3. Calcolo qualsivoglia vettore di PageRank sfruttando la funzione di estrapolazionenella forma (23).33

Considerazioni computazionali: il punto (1) è la solita iterazione delle potenze alcosto O(m+ n) per passo, il punto (2) costa 10n operazioni oltre a due prodotti PTα x,il punto (3) 3n + 1 operazioni. Al solito valgono le considerazioni fatte allo scopo disfruttare matvec come indice di complessità.Riportiamo una facile subroutine Fortran che implementa quanto scritto:

1 PROGRAM PageRankMinEX23 IMPLICIT NONE45 INTEGER , PARAMETER :: dp=KIND (0.d0), nodi=26 REAL(dp), PARAMETER :: alpha =0.997 INTEGER :: n, m, k, matvec=0, maxit =5000, &8 it9 INTEGER , DIMENSION (:), ALLOCATABLE :: i, j, d

10 REAL(dp), DIMENSION (:), ALLOCATABLE :: p1, p211 REAL(dp), DIMENSION (:), ALLOCATABLE :: x, y, tmp1 , tmp212 REAL(dp), DIMENSION (nodi) :: c_list13 REAL(dp) :: tol=10e-13, gamma , r1415 ! REQUIRES: c_list array ordinato.16 c_list = (/ 0.90, 0.94 /)1718 ! Lettura dati e allocazione arrays.19 OPEN (UNIT=2,FILE=’rankmat.txt ’)20 READ (2,*) n21 READ (2,*) m22 ALLOCATE (i(m),j(m),d(n),x(n),y(n),p1(n),p2(n),tmp1(n),tmp2(n))2324 ! Costruzione dei vettori i,j,d.25 d = 026 DO k=1,m27 READ (2,*) i(k), j(k)28 d(i(k)) = d(i(k)) + 129 END DO3031 ! Scelta del vettore casuale x e normalizzazione.32 DO k=1,n33 CALL RANDOM_NUMBER(x(k))34 END DO35 x = x / SUM(ABS(x))3637 ! Riempimento degli arrays p1 e p2.38 p1 = x39 p2 = x4041 ! Costruzione dei vettori di rank sui nodi di interpolazione.42 DO it = 1,maxit43 y = x44 CALL prodotto(i,j,d,m,n,x,c_list(nodi))

34

45 matvec = matvec + 146 p1 = p1 + (c_list (1)** matvec )/( c_list(nodi )** matvec) * (x - y)47 r = SUM(ABS(x-y))48 x = x / SUM(ABS(x))49 IF (r < tol) THEN50 EXIT51 END IF52 END DO53 p2 = x5455 ! Calcolo valore gamma di minimizzazione.56 tmp1 = p2 - p157 tmp2 = p158 CALL prodotto(i,j,d,m,n,tmp1 ,alpha)59 CALL prodotto(i,j,d,m,n,tmp2 ,alpha)60 matvec = matvec + 261 gamma = -1 * (DOT_PRODUCT(tmp1 -(p2-p1),tmp2 -p1)) / (NORM2(tmp1 -(p2-p1 ))**2)6263 ! Calcolo vettore rank.64 x = (1 - gamma) * p1 + gamma * p26566 ! Scrittura dati.67 OPEN (UNIT=3,FILE=’rank ’)68 DO k=1,n69 WRITE (3,*) x(k)70 END DO7172 WRITE (*,*) ’Prodotti matrice -vettore svolti:’, matvec7374 END PROGRAM

3.5 Sperimentazioni numeriche.In questo paragrafo confronteremo i tre approcci interpolativi intrapresi nella sezionecorrente della trattazione non dal punto di vista della complessità, che rimane comun-que sulla stessa linea asintotica, bensì dell’accuratezza nell’approssimazione del vet-tore di Rank. Valuteremo a parità di vicinanza dei nodi rispetto al valore da calcolarequale soluzione delle precedenti offra prestazioni migliori. Poichè vorremo constatareanche ad occhio nudo quanto ottenuto non sperimenteremo sulla unipi1000 ma suuna matrice di dimensione inferiore: si è costruita una rete di adiacenza di 200 nodia partire da http://poisson.phc.unipi.it che chiameremo poisson200, come pri-ma i relativi dettagli saranno posti in appendice. Per il fatto che l’intera esposizionetratta di problematiche legate alla scelta di valori α vicini ad 1, si è assunto su tuttala nostra sperimentazione di voler calcolare il vettore PageRank di poisson200 perα = 0, 99: per ognuno dei 3 metodi risolutivi proposti si è fatto man mano aumentareil valore del massimo nodo, assumendo che nel caso di interpolazione Lagrange i nodisono sempre 7, e si sono tracciati grafici di confronto con una soluzione della stessaistanza mediante Arnoldi-Extrapolation. Ecco alcuni risultati.

35

36

Figura 3: Sperimentazioni sull’interpolazione con base di Lagrange: sono cerchiati imaggiori 4 valori del Rank che vengono precisamente individuati in tutti e 4 i casi.37

38

Figura 4: Sperimentazioni sulla procedura al paragrafo 3.3: notare la pesante quantitàdi errore per valore massimo dei nodi troppo basso.39

40

Figura 5: Sperimentazioni sulla procedura di minimizzazione del residuo.41

Prima di commentare quanto ottenuto riportiamo anche alcuni dati numerici: in-dichiamo con rα il valore del Rank ottenuto tramite Arnoldi-Extrapolation, p(α) quelloottenuto mediante inter-estrapolazione e d il numero dei nodi d’interpolazione.La tabella seguente riporta il valore di ||rα−p(α)||p nei vari casi esaminati sui grafici pre-cedenti.

r: [0,70 , 0,75] r: [0,75 , 0,80] r: [0,85 , 0,90] r: [0,90 , 0,94]Interp. Lagrange 0,015922 0,0081184 0,0049290 0,0026219Simple Extr. 0,25773 0,025699 0,0097729 0,0049751Minimizzazione residuo 0,036434 0,028018 0,011066 0.0050112

Risulta evidente che per poter competere con un Arnoldi-Extrapolation l’idea in-terpolativa più efficace resta indubbiamente quella di utilizzare 7 nodi con base diLagrange: per avere un risultato accettabile è necessario scegliere come valore mas-simo almeno uno 0, 94.Altra proprietà del nostro primo approccio consiste nella forte precisione sulle com-ponenti maggiori (quelle opportunamente cerchiate sui grafici) a scapito dei valoriintermedi, questa buona condizione non è evidentemente mantenuta negli altri algo-ritmi e come vedremo sarà molto utile.A proposito degli altri due algoritmi implementati, per l’utilizzo di un numero mino-re di operazioni tendiamo a pagare una peggiore qualità delle approssimazioni. Inparticolare, l’interpolazione semplificata (paragrafo 3.3) risulta essere completamenteinefficace per valori dei nodi troppo distanti dal valore da estrapolare (si veda la cifrascritta in rosso sulla precedente tabella), mentre l’interpolazione mediante minimiz-zazione mostra carenze approssimative più dilazionate rispetto all’aumentare dellagrandezza dei nodi.Il fatto di utilizzare meno nodi comporta necessariamente minore precisione, come cipotremmo intuitivamente aspettare, nonostante le tecniche utilizzate attutiscano il piùpossibile tale perdita.4 Conclusioni: l’idea vincenteSiamo arrivati al punto saliente dell’intero ragionamento: quale dei due studi (Wu-Wei o Brezinski-Zaglia) fornisce la soluzione migliore al problema della perdita diprestazioni sul calcolo del PageRank per valori di α vicini a 1?

La risposta può non essere così immediata: se siamo interessati ad alte accura-tezze non possiamo che scegliere l’algoritmo Arnoldi-Extrapolation visto il fatto cheper avere risultati analoghi (α = 0.99) mediante interpolazione è necessario un costonon inferiore a quello di un’iterazione delle potenze con α = 0.94, come stabilito nelparagrafo precedente, ed un Arnoldi-Ex. su 0.99 risulta più performante, come giàvisto nel paragrafo 2.6.L’Arnoldi-Ex. presenta tuttavia un importante svantaggio rispetto alle tecniche di in-terpolazione: se si vuole studiare la variazione del vettore di Rank con l’avvicinarsia 1 sono necessari molteplici risultati per differenti α , utilizzando l’Arnoldi-Ex. ènecessario ripetere ogni volta l’intero calcolo e ciò è computazionalmente non pro-fiquo. Considerando invece l’approccio di Brezinski, tutti i calcoli che si sono svolti42

per costruire la funzione di estrapolazione p(α) vengono effettuati una sola volta e perconoscere i valori di rα1, . . . , rαr sarà necessario calcolarci soltanto p(α1), . . . p(αd) conun dispendio ridotto di operazioni nelle computazioni successive.Come già accennato in precedenza, l’algoritmo di interpolazione con base di Lagran-ge ha la proprietà di individuare i valori più elevati del vettore di Rank con estremaprecisione anche con scelta di nodo massimo molto distante dal valore da calcolare:risulta pertanto un approccio più efficiente dello stesso Arnoldi-Extrapolation nel casoin cui si vogliano individuare soltanto i siti più importanti della rete.Un’idea interessante potrebbe essere quella di combinare i due approcci seguiti: po-tremmo infatti ricavare i vettori di Rank sui nodi non mediante metodo delle potenze,bensì sfruttando l’algoritmo Arnoldi-Extrapolation, in tal modo avremmo una riduzionedelle iterazioni necessarie alla convergenza e un lieve vantaggio rispetto al calcolodiretto.5 Appendice: costruzione di matrici di adiacenza dalla

rete Internet.Le sperimentazioni effettuate hanno richiesto, come già detto, dati reali: in questaultima sezione spiegheremo come costruire matrici di adiacenza a partire da un qual-siasi nodo web.Sfruttiamo come base di partenza la function surfer.m disponibile sul sito exchangeufficiale di MATLAB, all’indirizzo http://www.mathworks.it/moler/ncm/surfer.m.Si tratta di una funzione che prende in ingresso il nodo di partenza scritto come strin-ga e un valore intero che indichi la dimensione della rete che verrà creata; in uscita èrestituita la matrice di adiacenza stessa e il vettore di stringhe contenente all’i-esimacomponente l’url dell’i-esimo nodo di rete. Noi vogliamo costruire una funzione chesfrutti surfer.m e che crei un output codificato conformemente al codice implemen-tato, oltre ad un’immagine che visualizzi l’entità della sparsità relativa alla matrice diadiacenza.

1 function extr_matr(url ,dim)23 [A,B] = surfer(url ,dim);45 spy(B);6 print -djpeg ’spy.jpg ’78 M = [];9 k = 0;

10 ins = 2;11 for i=1:dim12 for j=1:dim13 if (B(i,j) == 1)14 k = k+1;15 M(ins ,1) = i;16 M(ins ,2) = j;17 ins = ins + 1;18 end19 end

43

20 end2122 M(1,1) = dim;23 M(1,2) = k;2425 save(’rankmat.txt ’,’M’);26 save(’links ’,’A’);2728 end

Riporto inoltre una function necessaria ad individuare quali sono gli n siti piùimportanti data la matrice di adiacenza, il PageRank e l’array degli indirizzi dei nodi.1 function best_sites(n)23 r = load(’rank ’,’-ascii ’);4 load(’links.mat ’);5 bestpos = zeros(n,1);67 max = -1;8 maxpos = 1;9 for j=1:n

10 for i=2: length(r)11 if (r(i) > max)12 max = r(i);13 maxpos = i;14 end15 end16 r(maxpos) = 0;17 max = -1;18 bestpos(j) = maxpos;19 end2021 urls = cell(n,1);22 for i=1:n23 urls(i) = A(bestpos(i));24 end2526 save(’urls ’);2728 end

Concludiamo la trattazione con alcuni dati relativi alle matrici utilizzate, ossia launipi1000 e la poisson200.

44

Figura 6: spy e vettore PageRank della matrice unipi1000, con α = 0, 85.45

Figura 7: spy e vettore PageRank della matrice poisson200, con α = 0, 85.46

I 5 nodi più importanti di unipi1000:http://matricolandosi.unipi.it/feed/atomhttp://www.cisiaonline.it/area-tematica-tolc-economia/home-tolc-economiahttp://www.unipi.it/link/risorse.htm_cvt.htmhttp://www.pisauniversitypress.it/js/banner/overlayer_middle.phphttp://www.miur.it

I 5 nodi più importanti di poisson200:http://blog.gitorious.org/feedhttp://blog.gitorious.org/page/2http://blog.gitorious.org/2013/04/02/an-update-about-gitorious-v3-0/#commentshttp://blog.gitorious.orghttp://wp.me/uaNj

Riferimenti bibliografici[1] Gang Wu, Yimin Wei, An Arnoldi-Extrapolation algorithm for computing

PageRank, Journal of Computational and Applied Mathematics, Elsevier,2010.[2] C. Brezinski, M. Redivo-Zaglia, Rational Extrapolation for the PageRankvector, Mathematics of Computation, AMS, February 2008.

47