Phenquestions
I den här artikeln kommer vi att dyka in i GPU-programmering med Python. Med Pythons lätthet kan du låsa upp den otroliga datorkraften för grafikkortets GPU (grafikbehandlingsenhet). I det här exemplet arbetar vi med NVIDIA: s CUDA-bibliotek.
Krav
För den här övningen behöver du antingen en fysisk maskin med Linux och en NVIDIA-baserad GPU, eller starta en GPU-baserad instans på Amazon Web Services. Endera ska fungera bra, men om du väljer att använda en fysisk maskin måste du se till att du har de NVIDIA-egna drivrutinerna installerade, se instruktioner: https: // linuxhint.com / install-nvidia-drivers-linux
Du behöver också CUDA Toolkit installerat. I detta exempel används Ubuntu 16.04 LTS specifikt, men det finns nedladdningar tillgängliga för de flesta större Linux-distributioner på följande URL: https: // utvecklare.nvidia.com / cuda-nedladdningar
Jag föredrar .deb-baserad nedladdning, och dessa exempel antar att du valde den vägen. Filen du laddar ner är en .deb-paket men har inte ett .deb-tillägg, så byt namn på det för att ha ett .deb i slutet hans hjälpsamma. Sedan installerar du den med:
sudo dpkg -i paketnamn.deb
Om du uppmanas att installera en GPG-nyckel, följ instruktionerna för att göra det.
Nu måste du installera själva cuda-paketet. För att göra det, kör:
sudo apt-get uppdatering sudo apt-get install cuda -y
Den här delen kan ta ett tag, så du kanske vill ta en kopp kaffe. När det är klart rekommenderar jag att du startar om för att säkerställa att alla moduler laddas om ordentligt.
Därefter behöver du Anaconda Python-distributionen. Du kan ladda ner det här: https: // www.anakonda.com / nedladdning / # linux
Ta tag i 64-bitarsversionen och installera den så här:
sh Anaconda *.sh
(stjärnan i kommandot ovan ser till att kommandot körs oavsett den mindre versionen)
Standardinstallationsplatsen ska vara bra, och i den här handledningen använder vi den. Som standard installeras den till ~ / anaconda3
I slutet av installationen uppmanas du att bestämma om du vill lägga till Anaconda på din väg. Svara ja här för att underlätta körning av nödvändiga kommandon. För att säkerställa att denna ändring sker, efter att installationsprogrammet är helt klart, loggar du ut och loggar sedan in på ditt konto.
Mer information om installation av Anaconda: https: // linuxhint.com / install-anaconda-python-on-ubuntu /
Slutligen måste vi installera Numba. Numba använder LLVM-kompilatorn för att kompilera Python till maskinkod. Detta förbättrar inte bara prestanda för vanlig Python-kod utan ger också det lim som krävs för att skicka instruktioner till GPU i binär form. För att göra detta, kör:
conda installera numba
Begränsningar och fördelar med GPU-programmering
Det är frestande att tro att vi kan konvertera vilket som helst Python-program till ett GPU-baserat program, vilket dramatiskt accelererar dess prestanda. GPU: n på ett grafikkort fungerar dock betydligt annorlunda än en vanlig CPU i en dator.
Processorer hanterar många olika in- och utgångar och har ett brett sortiment av instruktioner för att hantera dessa situationer. De ansvarar också för åtkomst till minne, hantering av systembussen, hantering av skyddsringar, segmentering och in / ut-funktionalitet. De är extrema multitaskers utan specifikt fokus.
GPU: er är å andra sidan byggda för att bearbeta enkla funktioner med bländande snabb hastighet. För att åstadkomma detta förväntar de sig ett mer enhetligt tillstånd för in- och utmatning. Genom att specialisera sig i skalära funktioner. En skalarfunktion tar en eller flera ingångar men returnerar bara en enda utgång. Dessa värden måste vara typer som fördefinierats av numpy.
Exempel på kod
I det här exemplet skapar vi en enkel funktion som tar en lista med värden, lägger till dem tillsammans och returnerar summan. För att demonstrera kraften i GPU: n kör vi en av dessa funktioner på CPU: n och en på GPU: n och visar tiderna. Den dokumenterade koden är nedan:
importera numpy som np från timeit import default_timer som timer från numba import vectorize # Detta borde vara ett väsentligt högt värde. På min testmaskin tog det # 33 sekunder att köra via CPU och drygt 3 sekunder på GPU. NUM_ELEMENTS = 100000000 # Detta är CPU-versionen. def vector_add_cpu (a, b): c = np.nollor (NUM_ELEMENTS, dtype = np.float32) för i inom intervallet (NUM_ELEMENTS): c [i] = a [i] + b [i] return c # Detta är GPU-versionen. Notera @vectorize-dekoratören. Detta berättar för # numba att göra detta till en GPU-vektoriserad funktion. @vectorize (["float32 (float32, float32)"], target = "cuda") def vector_add_gpu (a, b): returnera a + b; def main (): a_source = np.enor (NUM_ELEMENTS, dtype = np.float32) b_source = np.enor (NUM_ELEMENTS, dtype = np.float32) # Time CPU-funktionen start = timer () vector_add_cpu (a_source, b_source) vector_add_cpu_time = timer () - start # Time GPU-funktionen start = timer () vector_add_gpu (a_source, b_source) vector_add_gpu_time = timer () - start # Rapporter utskrift gånger ("CPU-funktionen tog% f sekunder."% vector_add_cpu_time) print (" GPU-funktionen tog% f sekunder."% vector_add_gpu_time) return 0 if __name__ ==" __main__ ": main () För att köra exemplet, skriv:
python gpu-exempel.py
OBS: Om du stöter på problem när du kör ditt program, försök använda “conda install accelerate”.
Som du kan se går CPU-versionen betydligt långsammare.
Om inte, är dina iterationer för små. Justera NUM_ELEMENTS till ett större värde (på min verkade breakeven-märket vara cirka 100 miljoner). Detta beror på att installationen av GPU tar en liten men märkbar tid, så för att göra operationen värt det krävs en högre arbetsbelastning. När du har höjt den över tröskeln för din maskin kommer du att märka betydande prestandaförbättringar av GPU-versionen jämfört med CPU-versionen.
Slutsats
Jag hoppas att du har haft vår grundläggande introduktion till GPU-programmering med Python. Även om exemplet ovan är trivialt ger det det ramverk du behöver för att ta dina idéer vidare med kraften i din GPU.
