AI & GPU
Tensorflow Gpu

TensorFlow GPU: A mélytanulás teljesítményének gyorsítása

Bevezetés

A mélytanulás forradalmasította a mesterséges intelligencia területét, lehetővé téve áttöréseket a számítógépes látásban, a természetes nyelvfeldolgozásban és számos más területen. E forradalom középpontjában a Google által fejlesztett nyílt forráskódú gépi tanulási keretrendszer, a TensorFlow áll. Míg a TensorFlow futtatható CPU-n, a GPU-k erejének kihasználása elengedhetetlen a komplex neurális hálózatok hatékony betanításához és következtetéséhez. Ebben a cikkben megvizsgáljuk, hogyan használja ki a TensorFlow a GPU-kat a mélytanulási feladatok gyorsítására, és átfogó útmutatót adunk a TensorFlow GPU-teljesítmény beállításához és optimalizálásához.

Kulcsfogalmak

GPU-k vs. CPU-k

  • A GPU-k (Graphics Processing Units) olyan speciális hardverek, amelyek párhuzamos adatfeldolgozásra lettek tervezve. Ezernyi magot tartalmaznak, amelyek a lebegőpontos műveletek végrehajtására vannak optimalizálva, így ideálisak a mélytanulási számításokhoz.
  • A CPU-k (Central Processing Units) általános célú processzorok, amelyek a szekvenciális feladatokban és a komplex logikában jeleskednek. Bár a CPU-k kezelni tudják a mélytanulási feladatokat, jelentősen lassabbak a GPU-khoz képest.

CUDA és cuDNN

  • A CUDA (Compute Unified Device Architecture) egy párhuzamos számítási platform és programozási modell, amelyet az NVIDIA fejlesztett ki. Lehetővé teszi a fejlesztők számára, hogy kihasználják az NVIDIA GPU-k erejét általános célú számításokhoz.
  • A cuDNN (CUDA Deep Neural Network library) egy GPU-gyorsított könyvtár a mély neurális hálózatok primitívjeihez. Magasan optimalizált megvalósításokat biztosít a mélytanulás gyakori műveleteihez, mint például a konvolúció, a pooling és az aktivációs függvények.

TensorFlow GPU-támogatás

A TensorFlow zökkenőmentes integrációt kínál az NVIDIA GPU-kkal a CUDA és a cuDNN használatán keresztül. Automatikusan észleli a rendelkezésre álló GPU-kat, és elosztja a számítási terhelést közöttük. A TensorFlow széles körű támogatást nyújt az NVIDIA GPU-architektúrákhoz.Itt a magyar fordítás a megadott markdown fájlhoz. A kódban nem fordítottam le a kódot, csak a megjegyzéseket. Nem adtam hozzá további megjegyzéseket a fájl elejéhez.

  • Turing (RTX 20 sorozat)
  • Volta (Tesla V100)
  • Pascal (GTX 10 sorozat, Titan X)
  • Maxwell (GTX 900 sorozat)
  • Kepler (GTX 600/700 sorozat)

TensorFlow GPU beállítása

Hardver követelmények

A TensorFlow GPU-gyorsítással való futtatásához olyan NVIDIA GPU-ra van szükség, amelynek számítási képessége legalább 3.5. Néhány népszerű választás:

  • NVIDIA GeForce RTX 2080 Ti
  • NVIDIA Tesla V100
  • NVIDIA Titan RTX

Győződj meg róla, hogy a rendszered elegendő CPU-val, RAM-mal és tápegységgel rendelkezik a GPU támogatásához.

Szoftver követelmények

  • NVIDIA GPU illesztőprogramok (418.x vagy újabb verzió)
  • CUDA Toolkit (10.1 vagy újabb verzió)
  • cuDNN (7.6 vagy újabb verzió)
  • Python (3.5-3.8 verzió)
  • TensorFlow GPU csomag

Telepítési lépések

  1. Telepítsd az NVIDIA GPU illesztőprogramokat az NVIDIA hivatalos weboldaláról.
  2. Töltsd le és telepítsd a CUDA Toolkit-et az NVIDIA CUDA letöltési oldaláról.
  3. Töltsd le a cuDNN-t az NVIDIA cuDNN weboldaláról (NVIDIA Fejlesztői fiók szükséges).
  4. Csomagold ki a cuDNN fájlokat és másold őket a CUDA Toolkit könyvtárba.
  5. Hozz létre egy új Python virtuális környezetet és aktiváld azt.
  6. Telepítsd a TensorFlow GPU csomagot a pip használatával:
pip install tensorflow-gpu
  1. Ellenőrizd a telepítést a következő Python kód futtatásával:
import tensorflow as tf
print("Num GPUs Available: ", len(tf.config.list_physical_devices('GPU')))

Ha a kimenet egy vagy több GPU-t mutat, a telepítés sikeres volt.

Alapvető TensorFlow GPU műveletek

GPU támogatás engedélyezése

Alapértelmezés szerint a TensorFlow automatikusan használja a rendelkezésre álló GPU-kat a számításokhoz. Explicit módon engedélyezheted vagy tilthatod le a GPU támogatást a következő kóddal:

import tensorflow as tf
 
# GPU engedélyezése
tf.config.set_visible_devices(tf.config.list_physical_devices('GPU'), 'GPU')
 
# GPU letiltása
tf.config.set_visible_devices([], 'GPU')

Eszköz elhelyezés naplózása

Annak érdekében, hogy lásd, hogy a TensorFlow mely eszközöket használja az egyes műveletekhez, engedélyezheted az eszköz elhelyezés naplózását:

tf.debugging.set_log_device_placement(True)

Ez kinyomtatja az eszközt (CPU vagy GPU), amelyen minden művelet végrehajtásra kerül.

### Manuális eszköz elhelyezés

Manuálisan elhelyezhetsz bizonyos műveleteket a CPU-n vagy a GPU-n a `tf.device` kontextuskezelő használatával:

```python
with tf.device('/CPU:0'):
    # Műveletek, amelyek a CPU-n vannak elhelyezve
    cpu_output = tf.math.reduce_sum(tf.random.normal([1000, 1000]))

with tf.device('/GPU:0'):
    # Műveletek, amelyek a GPU-n vannak elhelyezve
    gpu_output = tf.math.reduce_sum(tf.random.normal([1000, 1000]))

GPU memória növekedésének korlátozása

Alapértelmezés szerint a TensorFlow lefoglalja az összes elérhető GPU memóriát, ami túlcsordulási hibákhoz vezethet. Ennek megakadályozására a TensorFlow-t úgy lehet konfigurálni, hogy dinamikusan foglalja a GPU memóriát:

gpus = tf.config.list_physical_devices('GPU')
if gpus:
    try:
        for gpu in gpus:
            tf.config.experimental.set_memory_growth(gpu, True)
    except RuntimeError as e:
        print(e)

Ez lehetővé teszi a TensorFlow számára, hogy fokozatosan foglalja a GPU memóriát, ahogy szükséges, csökkentve a túlcsordulási hibák kockázatát.

Teljesítmény összehasonlítás: CPU vs GPU

Annak bemutatására, hogy milyen teljesítménynyereséget lehet elérni a GPU-k használatával a TensorFlow-ban, hasonlítsuk össze egy egyszerű konvolúciós neurális hálózat betanítási idejét a MNIST adatkészleten CPU-n és GPU-n.

CPU betanítás

import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
 
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
x_train = x_train[..., tf.newaxis]
x_test = x_test[..., tf.newaxis]
 
model = Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    MaxPooling2D((2, 2)),
    Conv2D(64, (3, 3), activation='relu'),
    MaxPooling2D((2, 2)),
    Conv2D(64, (3, 3), activation='relu'),
    Flatten(),
    Dense(64, activation='relu'),
    Dense(10)
])
 
model.compile(optimizer='adam',
   .

loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=['accuracy'])

with tf.device('/CPU:0'):

CPU-n történő betanítás

model.fit(x_train, y_train, epochs=5, batch_size=64, validation_data=(x_test, y_test))


Egy Intel Core i7-9700K CPU-n a betanítás körülbelül 100 másodpercet vesz igénybe egy epochhoz.

### GPU-s betanítás

Ugyanennek a modellnek a GPU-n történő betanításához egyszerűen távolítsd el a `tf.device` kontextuskezelőt:

```python
model.fit(x_train, y_train, epochs=5, batch_size=64, validation_data=(x_test, y_test))

Egy NVIDIA GeForce RTX 2080 Ti GPU-n a betanítás körülbelül 10 másodpercet vesz igénybe egy epochhoz, ami 10-szeres gyorsulást jelent a CPU-hoz képest.

Ezek az eredmények a GPU-k mély tanulási feladatokban elért jelentős teljesítménynövekedését demonstrálják. A gyorsulás még kifejezettebb lehet nagyobb modellek és adatkészletek esetén.

Több GPU-s és elosztott betanítás

A TensorFlow támogatja a több GPU-s és elosztott betanítást, lehetővé téve, hogy a modelleket több GPU-n és gépen skálázd a még gyorsabb betanítási időkért.

Több GPU-s betanítás

Több GPU kihasználásához egyetlen gépen a tf.distribute.MirroredStrategy API-t használhatod:

strategy = tf.distribute.MirroredStrategy()
 
with strategy.scope():
    model = Sequential([
        Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
        MaxPooling2D((2, 2)),
        Conv2D(64, (3, 3), activation='relu'),
        MaxPooling2D((2, 2)),
        Conv2D(64, (3, 3), activation='relu'),
        Flatten(),
        Dense(64, activation='relu'),
        Dense(10)
    ])
 
    model.compile(optimizer='adam',
                  loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                  metrics=['accuracy'])
 
model.fit(x_train, y_train, epochs=5, batch_size=64, validation_data=(x_test, y_test))

A MirroredStrategy automatikusan elosztja a modellt és az adatokat a rendelkezésre álló GPU-k között, arányosan csökkentve a betanítási időt a GPU-k számával.

Elosztott betanításElosztott képzés

Nagy léptékű képzéshez több gépen, a TensorFlow biztosítja a tf.distribute.experimental.MultiWorkerMirroredStrategy API-t:

strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy()
 
with strategy.scope():
    model = Sequential([
        Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
        MaxPooling2D((2, 2)),
        Conv2D(64, (3, 3), activation='relu'),
        MaxPooling2D((2, 2)),
        Conv2D(64, (3, 3), activation='relu'),
        Flatten(),
        Dense(64, activation='relu'),
        Dense(10)
    ])
 
    model.compile(optimizer='adam',
                  loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                  metrics=['accuracy'])
 
model.fit(x_train, y_train, epochs=5, batch_size=64, validation_data=(x_test, y_test))

A MultiWorkerMirroredStrategy kezeli a kommunikációt és szinkronizációt a munkavégzők között, lehetővé téve, hogy a képzést több gépre skálázza minimális kódmódosítással.

Felhasználási esetek és alkalmazások

A TensorFlow GPU-gyorsítás áttöréseket tett lehetővé különböző területeken, beleértve:

  • Számítógépes látás

    • Képosztályozás
    • Objektumfelismerés
    • Szemantikus szegmentáció
    • Arcfelismerés

  • Természetes nyelvfeldolgozás

    • Nyelvfordítás
    • Szövegkészítés
    • Érzelem-elemzés
    • Entitásfelismerés

  • Generatív modellek

    • Generatív antagonisztikus hálózatok (GANok)
    • Variációs autóenkóderek (VAE-k)
    • Stílustranszfer
    • Képfelbontás-növelés

  • Tudományos és numerikus számítások

    • Fizikai szimulációk
    • Számítási kémia
    • Bioinformatika
    • Pénzügyi modellezés

  • Hiperparaméter-hangolás és neurális architektúra-keresés

    • Automatizált modell-optimalizáció
    • Hatékony felfedezés a hiperparaméter-terekben
    • Új neurális hálózati architektúrák felfedezése

Ezek csak néhány példái a TensorFlow GPU-gyorsítás széles körű alkalmazásainak. Ahogy a mélytanulás területe tovább fejlődik.Kedves, a GPU-k egyre fontosabb szerepet fognak játszani a mesterséges intelligencia határainak kitolásában.

Következtetés

Ebben a cikkben megvizsgáltuk a TensorFlow GPU-gyorsítás erejét a mélytanulási feladatokhoz. Áttekintettük a GPU-számítás kulcsfontosságú fogalmait, a TensorFlow GPU-támogatással történő beállításának lépéseit, valamint a GPU-k TensorFlow-kódban való kihasználásának alapvető műveleteit. Bemutattuk a CPU-khoz képest elért jelentős teljesítménynövekedést, és megvizsgáltuk a több GPU-t és elosztott képzést használó stratégiákat a modellek még nagyobb adatkészletekhez és összetettebb architektúrákhoz való skálázása érdekében.

Ahogy a gyorsabb és hatékonyabb mélytanulás iránti kereslet növekszik, a GPU-k továbbra is nélkülözhetetlen eszközök lesznek a kutatók és a gyakorlati szakemberek számára egyaránt. A TensorFlow GPU-gyorsítás erejének kihasználásával új lehetőségeket tárhat fel a mesterséges intelligencia területén, és megküzdhet a szakterületén felmerülő legkihívóbb problémákkal.

Tehát, akár kezdő, aki éppen elkezdi mélytanulási utazását, akár tapasztalt szakember, aki modelljeit szeretné optimalizálni, a TensorFlow GPU-gyorsítás alkalmazása kulcsfontosságú lépés a legkorszerűbb eredmények elérése és a gépi tanulás határainak kitolása felé.

Pytorch Multi Gpu