Beräkningsuppgift

Dagens föreläsningar

•Introduktion till högprestandaberäkningar.

••Optimera rätt - profiling.

•Genomgång av NumPy.

••Andra bibliotek som är av intresse.

••Potensmetoden.

••Projektuppgiften.

••Tips.

Vad är HPC?

• HPC är en akronym för High Performance Computing, på svenska högprestandaberäkningar.

•• Löst definierat är HPC alla applikationer där exekveringstiden är en viktig parameter.

•• Det krävs kunskap inom såväl numerisk analys, programmering som datorarkitektur för att skapa bra programvara inom HPC.

OO inom HPC

• Traditionellt har objektorienterade lösningar ansetts som för långsamma för att användas i praktiken.

•• Vanligt att utveckla en applikation från grunden för ett enda eller en liten grupp problem.

•• På senare tid (olika lång beroende på vem man frågar) har begrepp som utvecklingstid och flexibilitet blivit viktigare även inom HPC.

•• De senaste 10 åren har en mängd ramverk för olika problemtyper skapats.

BLAS och LAPACK

• BLAS (Basic Linear Algebra Subroutines) innehåller optimerade grundläggande rutiner för att utföra vanliga operationer, tex. multiplikation med matriser och vektorer. Skrivet i Fortran 77 men finns även i en version i C.

• LAPACK använder BLAS för att implementera högnivåoperationer, såsom lösning av linjära system. Skrivet i Fortran 77 men försett med C-bindningar.

Varför använda BLAS/LAPACK?

• Dessa bibliotek har testats och optimerats under mer än två decennier. De är därmed säkra att använda och snabbare än ”hemmasnickrade” varianter.

•• Kompileras med optimerade inställningar för cache och dylikt på varje enskilt system.

•• Kan ställas in manuellt eller automatiskt med ATLAS som iterativt skapar en effektiv inställning.

Varför nämner jag detta här?

• De flesta HPC-applikationer kommer att köras i en miljö som utnyttjar BLAS/LAPACK för optimal prestanda.

•• Fortran och C kan anropas från Python.

•• Medvetenhet om BLAS/LAPACK leder till smidigare övergång från prototyp till skarp applikation.

Olika utvecklingsmetoder

• Det finns olika sätt att strukturera utvecklingen av HPC-applikationer.

•• Viktigt att utveckla på ett sätt som främjar återanvändning av kod.

•• Utvecklingsgrupperna blir allt större vilket ställer högre krav på modularisering.

•• Många ramverk utvecklas av utvecklare spridda över hela världen.

Alt. 1: Prestandan går först

• All kod skrivs i ett kompilerande lågnivåspråk, oftast Fortran 77 eller C.

• Fördelar:

–Prestanda. Högnivåspråk kan inte mäta sig med välskriven kod i F77 eller C.

––Portabilitet. Många litar inte på att applikationer skrivna i Fortran 90 eller C++ (med använing av STL) kommer att exekveras problemfritt på alla aktuella system.

• Nackdelar:––Lång utvecklingstid.––Främjar inte en flexibel design.––Svårt att skapa grafik och annan ”supportkod”.

Alt. 2: OO går först

• All kod skrivs i ett högnivåspråk, tex Python.

• Fördelar:––Snabb utveckling.––Flexibel struktur som främjar OO-tänkande och återanvändbara moduler.

––Portabilitet. Eftersom Python i sig är portabelt. Sanning med modifikation.

• Nackdelar:––Sämre prestanda.––Sund (?) skepsis inom HPC-världen.

Hybrid 1. Programbibliotek

• All kod skrivs i F77/C men vanliga uppgifter utförs med hjälp av programbibliotek för exempelvis visualiseringar.

• Fördelar:––Bibehållen prestanda.––Minskar utvecklingstiden.

• Nackdelar:––Relativt hög inlärningströskel.––Frågetecken för portabiliteten i biblioteken.

Hybrid 2. Python/NumPy/C

• Utveckla en prototyp i ren Python/NumPy. Gör sedan en profilering på applikationen och implementera de delar där vinsten blir störst i C eller Fortran.

• Fördelar:

––Kompromiss mellan prestanda och flexibilitet.

• Nackdelar:––Fortfarande långsammare än en välskriven

F77/C-applikation (men avståndet minskar vid arallellisering, mer om det snart).

Slutsats: Optimera rätt

• Det finns ingen lösning som ger både optimal prestanda och flexibilitet i utvecklingen.

• Konflikterande designmål: Ju mer detaljerat koden talar om hur saker och ting ska ske desto snabbare går det, men samtidigt tar utvecklingen längre tid och portabiliteten minskar.

Överdetaljerade lösningar

• Moderna kompilatorer är mycket bra på att optimera kod.

•• Ibland kan överambitiösa programutvecklare göra mer skada än nytta.

•• Överutnyttjning av kännedom om ett systems hårdvara leder till ickeportabla koder som inte med fördel kan återanvändas.

Exempel för profilering

• ...# test_py.py# -*- coding: iso-8859-15 -*-

import time, sys, random

def multiply(A,B,N):# Skapa resultatmatrisenC = [0 for i in range(N**2)]# Utför mmmfor i in range(N):

for j in range(N):for k in range(N):

C[i*N + j] += \A[i*N + k] * B[k*N + j];

return C

# Sätt matrisernas storlektry:

N = int(sys.argv[1])except:

N = 10

# Skapa vektorer av längd N^2A = [0 for i in range(N**2)]B = [0 for i in range(N**2)]

# Skapa matrisernarandom.seed(19)

for i in range(N):for j in range(N):

A[i*N + j] = random.random()B[i*N + j] = random.random()

startTime = time.clock()C = multiply(A, B, N)calcTime = time.clock() - startTime

print '%(N)dx%(N)d matris multiplicerad ' \'på %(calcTime)f sekunder' % locals()

Python Profiler

• Profileringen tar extra tid, ca 10%.

•• Bra optimeringar är funktioner som exekveras många gånger eller tar lång tid per anrop, helst både och.

$ python -m profile test_py.py 200

Multiplikation med 200x200 element utförd på 8.566453 sekunder120721 function calls in 8.471 CPU seconds

Ordered by: standard name

ncalls tottime percall cumtime percall filename:lineno(function)1 0.001 0.001 0.001 0.001 :0(__import__)4 0.000 0.000 0.000 0.000 :0(callable)4 0.000 0.000 0.000 0.000 :0(charmap_decode)2 0.000 0.000 0.000 0.000 :0(charmap_encode)2 0.000 0.000 0.000 0.000 :0(clock)

41 0.000 0.000 0.000 0.000 :0(endswith)1 0.002 0.002 8.469 8.469 :0(execfile)

...80000 0.186 0.000 0.186 0.000 :0(random)40406 0.285 0.000 0.285 0.000 :0(range)

...1 7.695 7.695 7.975 7.975 test_py.py:6(multiply)

NumPy/SciPy

• Moduler till Python som bygger på ett multidimensionellt array-objekt.

•• Skiljer sig från Python-listor genom att endast tillåta en datatyp per array.

•• Implementerade i C, vilket ger god prestanda.

•• Ger tillgång till högnivåfunktioner.

•• Dokumentation finns på www.numpy.org och www.scipy.org.

• En array är en multidimensionell datastruktur som lagrar numeriska värden av homogen typ.

•• Varje array har en rang som definieras av antalet axlar eller dimensioner i arrayen.

•• En punkt i 3D-rummet anges med tre tal [1,2,3].

• Detta betecknas som ett objekt av rang 1, där den enda dimensionen har längd 3.

•• Arrayen har rang 2 med dimensioner av längd 2 och 3.

Nomenklatur

• arrayer skapas med array-funktionen.

•• Första argumentet är en lista med tal.

•• Fledimensionell lista ger flerdimensionell array.

Skapa vektorer och matriser

>>> x = array([4, 6, 7])>>> print x[4 6 7]>>> A = array([ [6,8,2],[4,3,5] ])>>> print A[[6 8 2][4 3 5]]>>> x = array(1,2,3)Traceback (most recent call last):

File "<stdin>", line 1, in ?TypeError: typecode argument must be avalid type.

• array([1,2,3]) eller array((1,2,3)).

•• Hakar ger Python-listor medan vanliga parenteser ger tupletter.

•• Tupletter fungerar som listor men är statiska. Därmed är de snabbare.

•• Båda sätten ger samma array när den väl är skapad.

Hakar eller parenteser

Typer i NumPy

• Tillgängliga typer: Int, Float, Complex, Character, UnsignedInt8 samt Pythonobjekt.

•• Int, Float och Complex kan ges en explicit storlek genom att lägga till siffrorna 8, 16, 32 eller 64 (128), tex Float64. Siffran anger antal bitar som används för att spara talet. Om inget tal anges används lämpliga standardvärden.

•• Siffran 0 anger att minsta möjliga storlek ska användas.

•• array-funktionen sätter en typ som täcker in alla tal i listan. Alla element i arrayen får den ”största” typen.

Fler exempel

>>> a = array([1, 2, 3]) => Heltal>>> a = array([1.0, 2.0, 3.0]) => Flyttal>>> a = array(['a', 'b', 'c']) => ASCII>>> a = array([1, 2, 3.0]) => Flyttal>>> a = array(['a', 'b', 3.0]) => Ej tillåtetTraceback (most recent call last):

File "<stdin>", line 1, in ?TypeError: len() of unsized object

Vanligt misstag med heltalsarray

• Rekommendation: Ange alltid typ explicit.

>>> a = array([1,2,3])>>> print a / 2[0 1 1]>>> print a / 2.0[ 0.5 1. 1.5]>>> a = array([1,2,3], float_)>>> a / 2array([ 0.5, 1. , 1.5])

Fler sätt att skapa arrayer

• zeros och ones:>>> print zeros([2,3])[[0 0 0][0 0 0]]>>> print ones([2,3])[[1 1 1][1 1 1]]>>> print zeros([2,3]) + 3.14[[ 3.14 3.14 3.14][ 3.14 3.14 3.14]]

• identity:>>> print identity(5)[[1 0 0 0 0][0 1 0 0 0][0 0 1 0 0][0 0 0 1 0][0 0 0 0 1]]>>> eye(5)array([[ 1., 0., 0., 0., 0.], [ 0., 1., 0., 0., 0.], [ 0., 0., 1., 0., 0.], [ 0., 0., 0., 1., 0.], [ 0., 0., 0., 0., 1.]])

Omforma matriser

• Arrayer kan omformas så länge antalet element är konstant.

>>> print reshape(array(range(25)), (5,5))[[ 0 1 2 3 4][ 5 6 7 8 9][10 11 12 13 14][15 16 17 18 19][20 21 22 23 24]]>>> print reshape(array(range(24)), (3,-1))[[ 0 1 2 3 4 5 6 7][ 8 9 10 11 12 13 14 15][16 17 18 19 20 21 22 23]]>>> print reshape(identity(4), (2,8))[[ 1. 0. 0. 0. 0. 1. 0. 0.][ 0. 0. 1. 0. 0. 0. 0. 1.]]

Modernare syntax

>>> a = arange(60).reshape(3,4,5); print a[[[ 0 1 2 3 4] [ 5 6 7 8 9] [10 11 12 13 14] [15 16 17 18 19]]

[[20 21 22 23 24] [25 26 27 28 29] [30 31 32 33 34] [35 36 37 38 39]]

[[40 41 42 43 44] [45 46 47 48 49] [50 51 52 53 54] [55 56 57 58 59]]]

Vektorer måste vara rättvända

>>> A = mat(arange(9).reshape(3,3))>>> Amatrix([[0, 1, 2], [3, 4, 5], [6, 7, 8]])>>> x = arange(3)>>> xarray([0, 1, 2])>>> A*xTraceback (most recent call last):

File "<stdin>", line 1, in <module>File "D:\Program\Python25\Lib\site-packages\numpy\core\defmatrix.py",

line 159, in __mul__return N.dot(self, asmatrix(other))

ValueError: objects are not aligned

>>> x = x.reshape(3,1)>>> A*xmatrix([[ 5], [14], [23]])

Mer om arrayer

>>> x = array([1,2,3], float_)>>> x.dtypedtype('float64')>>> print x.itemsize8>>> A = array([[1,2,3],[4,5,6]], int_)>>> A.shape(2, 3)>>> A.dtypedtype('int32')

• Använd itemsize för att hämta en arrays elementstorlek och shape för att hämta arrayens form:

• Använd astype för att ändra elementstorlek:

>>> x = array([1,2,3], int_)>>> print x.itemsize, x.dtype4 int32>>> x = x.astype(float_)>>> print x.itemsize, x.dtype8 float64

Vanliga operationer

• Alla vanliga matematiska operatorer fungerar, såsom +, -, * och /. Alla operatorer, liksom trigonometriska funktioner, opererar elementvis.

>>> x = array([1,2,3], float_)>>> x / 5array([ 0.2, 0.4, 0.6])>>> x + 3array([ 4., 5., 6.])>>> cos(x)array([ 0.54030231, -0.41614684, -0.9899925 ])>>> y = array([4,5,6])>>> x + yarray([ 5., 7., 9.])>>> x * yarray([ 4., 10., 18.])>>> dot(x,y)32.0>>> cross(x,y)array([-3., 6., -3.])

Några ord om in-place-operationer

• array-objektet i NumPy stödjer in-placeoperatorer som += och -=. Dessa fungerar som förväntat.

>>> x = array([1,2,3], float_)>>> y = array([4,5,6], float_)>>> x += y>>> xarray([ 5., 7., 9.])>>> x *= 2>>> xarray([ 10., 14., 18.])

Delar av vektorer

• Vektorer refereras och ändras på samma sätt som vanliga Pythonlistor fast med kolonnotation.

>>> x = array([1,2,3,4,5], float_)>>> print x[0:2][ 1. 2.]>>> print x[2]3.0>>> print x[2:][ 3. 4. 5.]>>> print x[2:-2][ 3.]>>> print x[2:-1][ 3. 4.]>>> print x[:-2][ 1. 2. 3.]>>> x[3] = 13.6>>> print x[ 1. 2. 3. 13.6 5. ]

• transpose(A) transponerar arrayen A.

•• diagonal(A, k=0) ger diagonalen i a med offset k från huvuddiagonalen.

•• trace(A,k=0) ger summan av diagonalen med offset k från huvuddiagonalen.

•• max(x) returnerar största komponenten i x.

• Använd max(absolute(x)) för max absolutbelopp. Finns även min och mean.

•• Fler funktioner i NumPy-dokumentationen.

Fler funktioner för arrayer

• Eftersom en array är ett vanligt objekt är enklaste sättet att spara en array att använda modulen pickle (cPickle).

•• För permanent förvaring använd objektsdatabaser med shelve.

•• Se Programmering i Python 8.7 för detaljer.

Spara arrayer

Matriser

• Matriser skapas med matrix(…).

•• Matriser överlagrar * med matris-matrismultiplikation.

>>> A = matrix("1 2 3; 4 5 6; 7 8 9")>>> print A[[1 2 3] [4 5 6] [7 8 9]]>>> A = matrix(arange(25).reshape(5,5))>>> print A[[ 0 1 2 3 4] [ 5 6 7 8 9] [10 11 12 13 14] [15 16 17 18 19] [20 21 22 23 24]]>>> A*Amatrix([[ 150, 160, 170, 180, 190], [ 400, 435, 470, 505, 540], [ 650, 710, 770, 830, 890], [ 900, 985, 1070, 1155, 1240],[1150, 1260, 1370, 1480, 1590]])

Operationer med matriser

>>> from numpy import *>>> A = matrix(random.rand(4,4))>>> print A[[ 0.03181996 0.03786336 0.72718153 0.42445215] [ 0.83435511 0.88470687 0.10093175 0.1513235 ] [ 0.56623217 0.34608716 0.96518451 0.46913041] [ 0.79799389 0.69613646 0.90271155 0.16759695]]>>> print A.T # Transponat[[ 0.03181996 0.83435511 0.56623217 0.79799389] [ 0.03786336 0.88470687 0.34608716 0.69613646] [ 0.72718153 0.10093175 0.96518451 0.90271155] [ 0.42445215 0.1513235 0.46913041 0.16759695]]>>> print A.I # Invers[[-4.68561986 -0.59393174 4.94928844 -1.45088847] [ 4.15209731 1.53744987 -4.84813134 1.66701679] [ 0.74242064 -0.9434959 -0.95006093 1.63101736] [ 1.06492405 1.5237964 1.68911183 -2.8342355 ]]

Delar av matriser

>>> a = arange(60).reshape(3,4,5); print a[[[ 0 1 2 3 4] [ 5 6 7 8 9] [10 11 12 13 14] [15 16 17 18 19]] [[20 21 22 23 24] [25 26 27 28 29] [30 31 32 33 34] [35 36 37 38 39]]

[[40 41 42 43 44] [45 46 47 48 49] [50 51 52 53 54] [55 56 57 58 59]]]

>>> print a[...,3][[ 3 8 13 18] [23 28 33 38] [43 48 53 58]]>>> print a[1,...,3][23 28 33 38]>>> print a[:,:,2][[ 2 7 12 17] [22 27 32 37] [42 47 52 57]]>>> print a[:,:,2][[ 2 7 12 17] [22 27 32 37] [42 47 52 57]]

Koppla C till Python

• Python är skrivet i C vilket gör att kopplingen kan ske sömlöst.

•• Att koppla C-moduler till Python är inte trivialt men heller inte svårt.

•• En detaljerad beskrivning finns i Programmering i Python kapitel 21.

•• Det går även att inkludera Python i C genom Pythons C-API. Se www.python.org.

•• Använd SWIG, www.swig.org.

Koppla Fortran till Python

• Fortran kan kopplas till Python med PyFort.

•• Se pyfortran.sourceforge.net där det finns en bra tutorial som bland annat visar hur man kopplar och använder en BLAS-rutin från Python.

Koppla Matlab till Python

• Matlab kan kopplas till Python med antingen PyMat (claymore.engineer.gvsu.edu/~steriana/Python/pymat.html) eller MatPy (matpy.sourceforge.net).

•• Python kan kommunicera med en Matlabapplikation och överföra variabler från Matlab till Python och vice versa.

GNU Scientific Library

• GSL innehåller funktionalitet inom en mängd områden, exempelvis wavelets, ODE och numerisk integrering.

•• Det finns bra Pythonbindningar till GSL.

•• Se www.gnu.org/software/gsl/

Scientific Python, SciPy

• Programpaket för vetenskapliga tillämpningar.

•• Grundläggande algebra (vektorer, tensorer, fält).

•• Automatisk derivering, interpolation, integration, et cetera.

•• Statistik.

•• Visualisering.

•• http://www.scipy.org.

Återkoppling BLAS/LAPACK

• Så småningom måste en prototyp omvandlas till en skarp applikation.

•• Designa prestandakänsliga delar med BLAS/LAPACK i åtanke.

•• Detta gör att implementeringen i F77/C går lätt. matrixmultiply, dot och andra funktioner i NumPy kan ersättas med ekvivalenta anrop till BLAS/LAPACK.

•• Minskar risken för att fel introduceras i nyimplementationen.

•• Använd inte för mycket högnivåkonstruktioner i kod som ni misstänker ska implementeras om.

Parallellberäkningar i Python

• Python kan användas på parallelldatorer, ett flertal alternativ finns, tex PyMPI, LamMPI, MPICH, OpenMPI.

•• När antalet processorer ökar minskar försprånget för F77/C. Nätverkets hastighet blir flaskhalsen.

Tidtagning

• Medelvärde eller kortaste tid?

# time01.py

def testFunction():L = []for i in range(100):

L.append(i)

if __name__=='__main__':from timeit import Timer# Ange vilken sats som ska testast = Timer("testFunction()", \

"from __main__ import testFunction")# Utför 100000 anropnoOfCalls = 100000total = t.timeit(number=noOfCalls)print "Testet tog %f sekunder, %f sekunder per anrop." % \(total, total/noOfCalls)

Projektet

• Syftet med projektet är att introducera numeriska beräkningar med Python och NumPy.

•• Prestandan undersöks genom att implementera potensmetoden för att beräkna egenvärden.

•• Programmet förses med ett grafiskt gränssnitt för att förenkla användningen.

Potensmetoden

• Beräknar största egenvärdet och korresponderande egenvektor för en kvadratisk matris A.

• Kräver att A är diagonaliserbar och att egenvärdena kan ordnas efter magnitud.

•• Luddig förklaring: Ax skalar x ”mest” i den riktning som ges av egenvektorn som hör till största egenvärdet. Därmed ger successiva multiplikationer allt större utslag i denna riktning.

•• Se hemsidan för länk till en matematisk härledning.

•• Se även kursbok i numerisk analys, tex Heath.

Algoritm

• Avsluta iterationen då förändringen e i ett steg understiger en given tolerans.

x0 = startgissningfor k = 1, 2, ...yk = Axk-1xk = yk / normmax(yk)end

Resultat

• Den största egenvektorn ges av:

• Det största egenvärdet ges av:

• Skalning av x, vilket ger:

• Observera att egenvärdet inte behöver beräknas under iterationsprocessen.

Startgissning

• Startgissningen x0 får inte vara ortogonal mot egenvektorn v till största egenvärdet.

•• A skalar i egenvärdets riktning. Om x0 är ortogonal mot v finns ingen komponent att skala.

•• I praktiken introducerar avrundningsfel en komponent i v:s riktning som kommer att ge rätt resultat så småningom.

Tolerans

• Svårt att på förhand veta vad som är en ”rimlig” tolerans.

•• Prova 10-4-10-7 i projektet.

Tips inför projektet

• sys.argv innehåller parametrar från terminalen.

•• Skicka in A som ett argument till funktionen som utför potensitereringen. På detta sätt kan man enkelt testa metoden på givna matriser.

•• Utveckla grafik och beräkning separat. En beräkningsmodul kan testas från terminalen. Ett GUI kan testas med ”låtsasmoduler” som returnerar testdata.