Clase 4

1. Programación y Computación
paralela (4)
Integración, Monte Carlo,
Metropolis
Glen D. Rodríguez R.
Basado en material de J. Demmel
1

2. Links
• Capítulo 4 del libro de Pacheco
• Ver http://www.old-
npac.org/users/gcf/slitex/CPS615NI95/index.html
• Ver http://www.old-
npac.org/projects/cps615spring00/presentations-
html/cps615nic95/
• Ver http://www.old-
npac.org/projects/cpsedu/summer98summary/examples/mpi-
c/mpi-c.html
2

3. Integración
• Se puede integrar en n dimensiones, pero por ahora
discutiremos sólo en una dimensión.
• Para n mayor de 2, el método Monte Carlo y similares tiene
muchas ventajas
• Se desea calcular la integral de la función f(x) de x=a
hasta x=b
b
I=
∫a
f(x) dx
• Implícitamente se asume que f(x) es relativamente
suave, se determina un conjunto de puntos de
“interpolación” o de malla xi en la región a ≤ x ≤ b y se
calcula la integral en término de los valores de f(x) y los
puntos de la malla.
3

4. Regla trapezoidal
• Se asume que f)x= es “o constante o lineal” en un
intervalo entre dos puntos
• I = 0.5*(b-a)*(f(a)+f(b)), o si no (menos preciso)
• I = (b-a)*f((a+b)/2)
f(a)
f(b)
0 X=a X=b x
4

5. Regla de Simpson
• Se asume que f(x) es una función cuadrática
• I = (b-a)*(f(a)+ 4f(xc)+f(b))/6
f(Xc)
f(a) f(b)
X=a xc = (a+ b)/2 X=b x5

6. Reglas iterativas
• Hay ciertas reglas (Newton-Cotes y Gaussiana) que
hacer aproximaciones de mayor orden de f(x)
• Son difíciles de programar y no muy “robustas” (funcionan mal
si f(x) varía muy rápido de forma no polinomial)
• En la práctica se usa Simpson o Trapezoidal iterativo –
Uar un número impar de puntos para aplicar simpson
de forma iterativa
ej.: Aplicar Simpson sobre cada uno de los 18 sub intervalos indiados por
Las flechas abajo. Trapezoidal iterativo involucraría 36 integrales
x0 x4 x8 x12 x16 x20 x24 x28 x32 x36
6

7. Método Monte Carlo
• El Monte Carlo más sencillo escoje puntos al azar
• La Integral es la suma de los valores de la función f(xRandom-i) en
los valores escogidos al azar xRandom-i multiplicados por el intervalo
de integración (b-a) y dividido por el número depuntos generados.
• Esta da un método robusto (y sin preferencias) que es fácil de
usar en integrales de n-dimensiones o integrales de funciones
problemáticas
• Se puede adaptar en límites complicados
• Se integra sobre regiones más grandes de lo necesario
• Se define f(x) =0 fuera del intervalo [a b]
a b
7

8. Hallar pi por integración con Monte Carlo
Otra forma de Monte Carlo: g(x,y) es un punto aleatorio en R2.
Ambas son equivalentes
8

9. x2 + y2 =1
y N= total de puntos
(cruces y equis)
n= puntos dentro
de la integral (cruces)
1 x A= área de la simulación
x x
+ + (área amarilla) = 1
x x
+ +
+ + x
+ x Integral ≈ A(n / N)
+
+
+ + +
+ +
1 x
Puntos al azar (x,y), donde x e y tienen distribución uniforme
9

10. Errores
• Para una integral con N puntos
• Monte Carlo tiene un error del orden de 1/N0.5
• Trapezoidal iterativo : 1/N2
• Simpson iterativo: 1/N4
• Pero en d dimensiones, todos menos el Monte Carlo
deben usar una malla de N1/d puntos por lado; no
funciona bien para N>3
• Monte Carlo aún tiene error 1/N0.5
• Error de Simpson es 1/N4/d
• Cuando usar Montecarlo? Cuando error de Montecarlo
es menor que error de Simpson para los mismos N
puntos? 1/N0.5 < 1/N4/d 0.5>4/d , o sea d>8
10

11. Trapezoidal Iterativo y Simpson iterativo
• Trapezoidal: Si tenemos N puntos N xi con
I= (b-a) (f(x0)+2f(x1)+2f(x2)+ ……
+2f(x(N-2))+f(x(N-1))/(2(N-1))
• O con Simpson:
I= (b-a) (f(x0)+4f(x1)+2f(x2)+ ……
+4f(x(N-2))+f(x(N-1))/(3(N-1))
• Se suman los f(xi) con diferentes pesos
• Note que ambos aproximan su cálculo en una región
tamaño (b-a)/(N-1) (el doble de eso para Simpson) que
tiende a cero si N es grande, así que la aprox. Es mejor
si N se agranda.
11

12. Las funciones de peso
• Se suman varios wi f(xi) y las diferentes reglas sólo con
diferentes wi
• Trapezoidal: para índices = 0, 1, 2, 3, ..., N-1
Se usa el patrón
wi ∝ 1, 2, 2, … 2, 2, 1
• Para los mismos índices, Simpson con N impar tieneel
patrón
wi ∝ 1, 2, 4, 2, 4, … 2, 4, 2, 4, 1
12

13. Computación paralela
0 1 2 3
x0 x4 x8 x12 x16 x20 x24 x28 x32
• Diferentes procesadores calculan independientemente diferentes puntos en la
integral y luego se suman los resultados de cada procesador
• Lo más natural es el escenario de la figura de arriba, con cada procesador
calculando una integral sobre una subregión
• x0 al x8 en proc. 0 … x24 to x32 en proc. 3 etc.
• La integral total es la suma de las sub-integrales calculadas en cada procesador
• Pero podría asignarse PUNTOS y no REGIONES a los procesadores
• x0 x4 x8 .. x32 al proc. 0
• x3 x7 x11 .. x31 al proc. 3
13

14. Integración con reglas y Paralelismo
• Es un ejemplo clásico de “master worker” donde los
procesadores individuales calculan arte de la integral.
• Se necesita usar “MPI rank” para determinar quien se
encarga de cada rango de la integración
• Luego se suma la contribución de cada procesador
• Suma global acumulativa (uno tras otro), por árbol o por
reducción al “master”.
14

15. Ejemplo 2: Monte Carlo con dist.uniforme
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include "mpi.h"
int main(int argc, char *argv[])
{
int nprocs, myproc;
int i, n, acum, sum_acum;
double pi_25= 3.141592653589793238462643;
double pi, w, x, y, error;
double t0, t1;
/* MPI initialization */
MPI_Init( &argc, &argv );
MPI_Comm_size( MPI_COMM_WORLD, &nprocs );
MPI_Comm_rank( MPI_COMM_WORLD, &myproc );
/* Determine the number of divisions to use */
if( argc == 2 ) { /* Take n from the command line argument */
sscanf( argv[1], "%d", &n );
} else {
if (myproc == 0)
{
printf("Enter the number of random points: (0 quits) ");fflush(stdout);
scanf("%d",&n);
} 15
}

16. Sigue….
if( myproc == 0 ) printf("Calculating pi using %d pointsn", n);
MPI_Bcast( &n, 1, MPI_INT, 0, MPI_COMM_WORLD); /* ??? Is this needed ??? */
/* Start the timer after a barrier command */
MPI_Barrier( MPI_COMM_WORLD );
t0 = MPI_Wtime();
pi = 0.0;
sum_acum=0;
acum=0;
srand( (unsigned)time( NULL )+myproc );
w = 1.0 / n;
for( i=myproc; i<n; i+=nprocs ) {
x = (double) rand()/RAND_MAX;
y = (double) rand()/RAND_MAX;
if (((x*x)+(y*y)) <= 1.0) {acum=acum+1;}
}
MPI_Allreduce( &acum, &sum_acum, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD );
pi= ((double) sum_acum)/(double) n;
pi = pi*4;
error = fabs( pi - pi_25 );
t1 = MPI_Wtime();
if( myproc == 0 ) {
printf("The calculated pi = %f (error = %f)n", pi, error);
printf("The calculation took %f seconds on %d nodesn", t1-t0, nprocs);
}
MPI_Finalize(); 16
}

17. Cómo mejorar la precisión de Monte Carlo
• Error absoluto de regla rectangular (peor que
trapezoidal), usando 10000 intervalos = 0.000199
• Error absoluto de regla trapezoidal usando 10000
intervalos = 0.000001
• Error absoluto promedio de Monte Carlo usando 10000
puntos y 10 simulaciones = 0.013521
• Como mejorar: no usar distribución uniforme. Se
necesita una "guía" al muestreo aleatorio que enfatiza el
muestreo donde la función es grande o varia
rápidamente.
• Ver ejemplo
• En ese caso, el error absoluto promedio de Monte Carlo
usando 10000 puntos y 10 simulaciones = 0.006479
17

18. x2 + y2 =1
y N= total de puntos
(cruces y equis)
n= puntos dentro
de la integral (cruces)
1 A= área de la simulación
x
+ + (área amarilla)= 0.857
x
+ + +
+
+ x Integral ≈ ????
+
+
+ + +
+ +
1 x
Puntos al azar (x,y), donde x, y no tienen dist. uniforme
18

19. Muestreo por importancia
• Quiero integrar en 1-D
• Se mete la función peso w
• Que debe satisfacer
• Cambiando la variable, con dy = w(x) dx, y(0) = 0, and y(1) = 1.
19

20. Muestreo por importancia
• Eso nos da
• La función w se escoge de tal forma que f/w sea cercana a una
constante. El muestreo uniforme en y se modifica (vuelve no
uniforme) al ser afectado por w. O dicho de otra forma, la integral
anterior es equivalente a la inicial, pero transformada por el cambio
de variable en una función con menos variaciones.
20

21. Programa Ejemplo 3
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include "mpi.h"
int main(int argc, char *argv[])
{
int nprocs, myproc;
int i, n;
double pi_25= 3.141592653589793238462643;
double pi, w, x, y, error, acum, sum_acum;
double t0, t1;
/* MPI initialization */
MPI_Init( &argc, &argv );
MPI_Comm_size( MPI_COMM_WORLD, &nprocs );
MPI_Comm_rank( MPI_COMM_WORLD, &myproc );
/* Determine the number of divisions to use */
if( argc == 2 ) { /* Take n from the command line argument */
sscanf( argv[1], "%d", &n );
} else {
if (myproc == 0)
{
printf("Enter the number of random points: (0 quits) ");fflush(stdout);
scanf("%d",&n);
} 21
}

22. Sigue…
if( myproc == 0 ) printf("Calculating pi using %d pointsn", n);
/* Broadcast the number of divisions to all nodes */
MPI_Bcast( &n, 1, MPI_INT, 0, MPI_COMM_WORLD); /* ??? Is this
needed ??? */
/* Start the timer after a barrier command */
MPI_Barrier( MPI_COMM_WORLD );
t0 = MPI_Wtime();
pi = 0.0;
sum_acum=0.0;
acum=0.0;
srand( (unsigned)time( NULL )+myproc );
w = 1.0 / n;
/* Each processor starts at a different value and computes its
* own contributions to pi. */
22

23. Sigue…
for( i=myproc; i<n; i+=nprocs ) {
x = (double) rand()/RAND_MAX;
y = (double) rand()/RAND_MAX;
if ((x>0.5) && (x<=0.8) && (y<=1.5-x) && (((x*x)+(y*y)) <= 1.0)) acum=acum+0.857;
if ((x>0.5) && (x<=0.8) && (y>1.5-x)) i=i-nprocs;
if ((x>0.8) && (y<=1.77-1.4*x) && (((x*x)+(y*y)) <= 1.0)) acum=acum+0.857;
if ((x>0.8) && (y>1.77-1.4*x)) i=i-nprocs;
if ( (x<=0.5) && (((x*x)+(y*y)) <= 1.0) ) acum=acum+0.857;
}
MPI_Allreduce( &acum, &sum_acum, 1, MPI_DOUBLE, MPI_SUM,
MPI_COMM_WORLD );
pi= ((double) sum_acum)/(double) n;
pi = pi*4;
error = fabs( pi - pi_25 );
t1 = MPI_Wtime();
if( myproc == 0 ) {
printf("The calculated pi = %f (error = %f)n", pi, error);
printf("The calculation took %f seconds on %d nodesn", t1-t0,
nprocs);
}
MPI_Finalize();
}
23

24. Paradigmas de Monte Carlo paralelo
• Master-worker: se genera los números
aleatorios en el nodo 0 y se pasan a los demás.
Todos los nodos computan.
24

25. Paradigmas de Monte Carlo paralelo
• Cliente-servidor: es un servidor de números
aleatorios, no procesa, sólo crea y envía los
randoms
25

26. Paradigmas de Monte Carlo paralelo
• Full workers: cada nodo genera sus propios
números aleatorios. El nodo 0 sólo cuida que
se siembren diferentes semillas o que se use la
misma semilla pero diferentes rangos.
26

27. Resolviendo Ec. de Poisson con Montecarlo
• Sea la ecuación de Poisson:
• Con fuente sinusoidal : -2π2 sen(π x) sen(π y)
• Y cero en todas las fronteras
• En diferencias finitas:
27

28. Solución con “random walks”
• De un punto (i,j) comenzar el “random walk”.La
probabilidad de moverse a cualquiera de los 4
puntos vecinos es ¼.
• Generar un número aleatorio para escoger el
vecino.
• Añadir g(x,y) en la nueva posición
• Repetir hasta llegar a una frontera
• Esto fue solo UNA “random walk”
• Después de N “random walks” el estimado de
u(i,j) es:
28

29. Paralelización de esta solución
• Hacer el siguiente proceso para todos los puntos
• Comenzar en una frontera
• De afuera hacia adentro
• Fila por fila
• Actualizar (intercambiar) data en el límite entre procesadores
• Actualizar el walk dentro de los puntos de un procesador
• Si el walk sale de un procesador, informarle al otro procesador
29

30. Metrópolis
• Se usa para integrales con funciones de peso.
• Genera un random walk pero guiado por una función
de peso w(x). Ejemplo en 2-D comenzando de un
punto (xi,yi):
1. Escoger δ, el step size
2. Generar dos aleatorios R1, R2 uniformes en el rango
[-1,1]
3. El nuevo punto será
1. xTi+1 = xi + δR1
2. yTi+1 = yi + δR2
4. Evaluar el ratio de w en el punto actual vs. el punto
anterior
1. r= w(xTi+1 ,yTi+1) / w(xi,yi)
30

31. Metrópolis
5. Si r>1 aceptar el nuevo punto y regresar a (2)
1. xi+1 = xTi+1 ; yi+1 = yTi+1
6. Si r<1 aceptar el nuevo punto con probabilidad r. O
sea, generar un aleatorio uniforme η en [0, 1] y
aceptar el punto solo si r>η (hacer lo mismo que en el
paso 5)
7. Caso contrario, rechazar el nuevo punto y volver a (2)
El step size no debe ser ni muy chico ni muy grande.
Los puntos obtenidos se usan luego para integrar, como
en MonteCarlo (Algo*n/N).
La paralelización es similar a la discutida para las otras
integrales con Montecarlo
31