Maximalizálja a stabil diffúziós teljesítményt és csökkentse a következtetési költségeket az AWS Inferentia2 | Amazon webszolgáltatások

A generatív mesterséges intelligencia modellek az elmúlt hónapokban gyors növekedést mutattak a valósághű szövegek, képek, kódok és hangok létrehozására szolgáló lenyűgöző képességeik miatt. Ezek közül a modellek közül a Stable Diffusion modellek kiemelkednek egyedülálló erejével a szöveges felszólítások alapján készült kiváló minőségű képek létrehozásában. A Stabil diffúzió sokféle kiváló minőségű képet készíthet, beleértve a valósághű portrékat, tájképeket és még absztrakt művészeteket is. Más generatív AI-modellekhez hasonlóan a stabil diffúziós modellek is nagy teljesítményű számítástechnikát igényelnek az alacsony késleltetésű következtetések levonásához.

Ebben a bejegyzésben bemutatjuk, hogyan futtathat Stable Diffusion modelleket és érhet el nagy teljesítményt a legalacsonyabb költséggel Amazon rugalmas számítási felhő (Amazon EC2) segítségével Amazon EC2 Inf2 példányok powered by AWS Inferentia2. Megnézzük a stabil diffúziós modell architektúráját, és végigjárjuk a stabil diffúziós modell összeállításának lépéseit a AWS Neuron és üzembe helyezi egy Inf2 példányban. Megvitatjuk azokat az optimalizálásokat is, amelyeket a Neuron SDK automatikusan végrehajt a teljesítmény javítása érdekében. Az AWS Inferentia2.1-n költséghatékonyan futtathatja a Stable Diffusion 1.5-es és 2-ös verzióit is. Végül bemutatjuk, hogyan telepíthet Stable Diffusion modellt egy Inf2-példányra Amazon SageMaker.

A Stable Diffusion 2.1 modell mérete lebegőpontos 32-ben (FP32) 5 GB és 2.5 GB bfoat16-ban (BF16). Egyetlen inf2.xlarge példány egy AWS Inferentia2 gyorsítóval rendelkezik 32 GB HBM memóriával. A Stable Diffusion 2.1 modell egyetlen inf2.xlarge példányon elfér. A Stable Diffusion egy szöveg-kép modell, amellyel különböző stílusú és tartalmú képeket hozhat létre, egyszerűen szöveges bevitellel. Ha többet szeretne megtudni a Stable Diffusion modell architektúráról, lásd: Hozzon létre kiváló minőségű képeket a Stable Diffusion modellekkel, és telepítse azokat költséghatékonyan az Amazon SageMaker segítségével.

Hogyan optimalizálja a Neuron SDK a stabil diffúziós teljesítményt

Mielőtt telepíthetnénk a Stable Diffusion 2.1 modellt AWS Inferentia2 példányokon, össze kell fordítanunk a modell összetevőit a Neuron SDK. A Neuron SDK, amely mély tanulási fordítót, futtatókörnyezetet és eszközöket tartalmaz, lefordítja és automatikusan optimalizálja a mély tanulási modelleket, hogy azok hatékonyan futhassanak Inf2-példányokon, és kivonják az AWS Inferentia2 gyorsító teljes teljesítményét. Vannak példák a Stable Diffusion 2.1 modellhez GitHub repo. Ez a notebook teljes körű példát mutat be a stabil diffúziós modell összeállítására, a lefordított Neuron modellek mentésére és a futási környezetbe való betöltésére következtetés céljából.

Az általunk használt StableDiffusionPipeline az Ölelő Arctól diffusers könyvtárat a modell betöltéséhez és lefordításához. Ezután összeállítjuk a modell összes összetevőjét a Neuron számára torch_neuronx.trace() és mentse az optimalizált modellt TorchScript-ként. A fordítási folyamatok meglehetősen memóriaigényesek lehetnek, és jelentős mennyiségű RAM-ot igényelnek. Ennek megkerülésére az egyes modellek nyomon követése előtt létrehozunk a deepcopy a csővezeték nyomon követett részének. Ezt követően a csővezeték objektumot a segítségével töröljük a memóriából del pipe. Ez a technika különösen hasznos alacsony RAM-mal rendelkező példányokon történő fordításkor.

Emellett a Stable Diffusion modellek optimalizálását is elvégezzük. Az UNet rendelkezik a következtetés legszámításigényesebb aspektusával. Az UNet komponens kettős kötegmérettel rendelkező bemeneti tenzorokon működik, és létrehoz egy megfelelő kimeneti tenzort, szintén kettős kötegmérettel, egyetlen kép létrehozásához. Az ezekben a tételekben lévő elemek teljesen függetlenek egymástól. Ezt a viselkedést kihasználva optimális késleltetést érhetünk el, ha minden Neuron magon egy köteget futtatunk. Az UNetet egy köteghez fordítjuk (egy köteggel bemeneti tenzorok használatával), majd használjuk a torch_neuronx.DataParallel API ennek az egyetlen kötegelt modellnek az egyes magokra való betöltéséhez. Ennek az API-nak a kimenete egy zökkenőmentes, két köteges modul: átadhatjuk az UNet-nek két köteg bemenetét, és egy két köteges kimenet kerül visszaadásra, de belsőleg a két egyköteges modell a két Neuron magon fut. . Ez a stratégia optimalizálja az erőforrás-kihasználást és csökkenti a késleltetést.

Fordítson le és helyezzen üzembe egy stabil diffúziós modellt egy Inf2 EC2 példányon

A Stable Diffusion modell Inf2 EC2 példányon történő fordításához és üzembe helyezéséhez jelentkezzen be a AWS felügyeleti konzol és hozzon létre egy inf2.8xlarge példányt. Ne feledje, hogy az inf2.8xlarge példányra csak a modell fordításához van szükség, mert a fordításhoz nagyobb gazdagépmemória szükséges. A Stable Diffusion modell egy inf2.xlarge példányon tárolható. A Neuron könyvtárakkal rendelkező legújabb AMI-t az alábbiak segítségével találhatja meg AWS parancssori interfész (AWS CLI) parancs:

aws ec2 describe-images --region us-east-1 --owners amazon --filters 'Name=name,Values=Deep Learning AMI Neuron PyTorch 1.13.? (Amazon Linux 2) ????????' 'Name=state,Values=available' --query 'reverse(sort_by(Images, &CreationDate))[:1].ImageId' --output text

Ebben a példában létrehoztunk egy EC2 példányt a Deep Learning AMI Neuron PyTorch 1.13 (Ubuntu 20.04) használatával. Ezután létrehozhat egy JupyterLab laborkörnyezetet, ha csatlakozik a példányhoz, és futtassa a következő lépéseket:

run source /opt/aws_neuron_venv_pytorch/bin/activate
pip install jupyterlab
jupyter-lab

Itt található egy notebook, amely a modell összeállításának és tárolásának összes lépését tartalmazza GitHub.

Nézzük meg az egyik szövegkódoló blokk összeállítási lépéseit. Más blokkok, amelyek a Stable Diffusion pipeline részét képezik, hasonlóan összeállíthatók.

Az első lépés az előképzett modell betöltése Hugging Face-ből. A StableDiffusionPipeline.from_pretrained metódus betölti az előre betanított modellt a folyamat objektumunkba, pipe. Ezután létrehozzuk a deepcopy a szövegkódolót a csővezetékünkből, hatékonyan klónozva azt. A del pipe A paranccsal törölhető az eredeti csővezeték objektum, felszabadítva az általa elfoglalt memóriát. Itt kvantáljuk a modellt BF16 súlyokra:

model_id = "stabilityai/stable-diffusion-2-1-base"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.bfloat16)
text_encoder = copy.deepcopy(pipe.text_encoder)
del pipe

Ez a lépés magában foglalja a szövegkódolónk becsomagolását a NeuronTextEncoder csomagolás. A lefordított szövegkódoló modul kimenete a következő lesz dict. Átalakítjuk a list írja be ezt a csomagolóanyagot:

text_encoder = NeuronTextEncoder(text_encoder)

Inicializáljuk a PyTorch tenzort emb néhány értékkel. A emb tenzort használjuk példa bemenetként a torch_neuronx.trace funkció. Ez a függvény nyomon követi a szövegkódolónkat, és egy Neuronra optimalizált formátumba fordítja. A lefordított modell könyvtárútvonala összekapcsolással jön létre COMPILER_WORKDIR_ROOT az alkönyvtárral text_encoder:

emb = torch.tensor([...])
text_encoder_neuron = torch_neuronx.trace(
        text_encoder.neuron_text_encoder,
        emb,
        compiler_workdir=os.path.join(COMPILER_WORKDIR_ROOT, 'text_encoder'),
        )

A lefordított szövegkódoló a segítségével kerül mentésre torch.jit.save. Model.pt fájlnév alatt van tárolva a text_encoder fordítóprogramunk munkaterületének könyvtára:

text_encoder_filename = os.path.join(COMPILER_WORKDIR_ROOT, 'text_encoder/model.pt')
torch.jit.save(text_encoder_neuron, text_encoder_filename)

A jegyzetfüzet hasonló lépéseket tartalmaz a modell további összetevőinek összeállításához: UNet, VAE dekóder és VAE post_quant_conv. Miután az összes modellt összeállította, az alábbi lépésekkel töltheti be és futtathatja a modellt:

1. Határozza meg a lefordított modellek elérési útját.
2. Töltsön be egy előképzett StableDiffusionPipeline modell, amelynek konfigurációja a bfloat16 adattípus használatára van megadva.
3. Töltse fel az UNet modellt két Neuron magra a segítségével torch_neuronx.DataParallel API. Ez lehetővé teszi az adatok párhuzamos következtetésének végrehajtását, ami jelentősen felgyorsíthatja a modell teljesítményét.
4. Töltse be a modell többi részeit (text_encoder, decoderés post_quant_conv) egyetlen neuronmagra.

Ezután futtathatja a folyamatot úgy, hogy beviteli szöveget ad meg promptként. Íme néhány kép, amelyet a modell generált a promptokhoz:

• Renaud Sechan portréja, toll és tus, bonyolult vonalas rajzok, készítette: Craig Mullins, Ruan Jia, Kentaro Miura, greg Rutkowski, Loundraw

• Régi szénbányász portréja a 19. században, gyönyörű festmény, greg rutkowski rendkívül részletgazdag arcfestményével

• Egy kastély az erdő közepén

Host Stable Diffusion 2.1 az AWS Inferentia2-n és a SageMakeren

A Stable Diffusion modellek SageMakerrel való üzemeltetéséhez a Neuron SDK-val való fordítás is szükséges. Az összeállítást idő előtt vagy futás közben is befejezheti a Large Model Inference (LMI) tárolók használatával. Az idő előtti összeállítás gyorsabb modellbetöltési időt tesz lehetővé, és ez az előnyben részesített lehetőség.

A SageMaker LMI konténerek kétféleképpen helyezhetik üzembe a modellt:

• Egy kód nélküli opció, ahol csak a serving.properties fájl a szükséges konfigurációkkal
• Hozd el a saját következtetési szkriptedet

Megnézzük mindkét megoldást, és átmegyünk a konfigurációkon és a következtetési szkripten (model.py). Ebben a bejegyzésben bemutatjuk a telepítést egy előre lefordított modell segítségével, amely egy an Amazon egyszerű tárolási szolgáltatás (Amazon S3) vödör. Ezt az előre összeállított modellt használhatja a telepítésekhez.

Konfigurálja a modellt a megadott szkripttel

Ebben a részben bemutatjuk, hogyan konfigurálhatja az LMI-tárolót a stabil diffúziós modellek tárolására. Az SD2.1 notebook a következőn érhető el GitHub. Az első lépés a modell konfigurációs csomag létrehozása a következő könyvtárstruktúra szerint. Célunk, hogy a modell hosztolásához szükséges minimális modellkonfigurációkat használjuk. A szükséges könyvtárstruktúra a következő:

<config-root-directory> / 
    ├── serving.properties
    │   
    └── model.py [OPTIONAL]

Ezután létrehozzuk a kiszolgáló.tulajdonságok fájl a következő paraméterekkel:

%%writefile code_sd/serving.properties
engine=Python
option.entryPoint=djl_python.transformers-neuronx
option.use_stable_diffusion=True
option.model_id=s3url
option.tensor_parallel_degree=2
option.dtype=bf16

A paraméterek a következőket határozzák meg:

• option.model_id – Az LMI konténerek s5cmd segítségével töltik be a modellt az S3 helyről, ezért meg kell adnunk azt a helyet, ahol az összeállított súlyaink vannak.
• option.entryPoint – A beépített kezelők használatához a transzformátorok-neuronx osztályt adjuk meg. Ha rendelkezik egyéni következtetési szkripttel, akkor azt kell megadnia.
• opció.dtype – Ez határozza meg, hogy a súlyokat meghatározott méretben kell betölteni. Ehhez a bejegyzéshez a BF16-ot használjuk, ami tovább csökkenti a memóriaigényünket az FP32-höz képest, és ennek köszönhetően csökkenti a késleltetést.
• opció.tensor_parallel_degree – Ez a paraméter határozza meg az ehhez a modellhez használt gyorsítók számát. Az AWS Inferentia2 chipgyorsítónak két Neuron magja van, így a 2-es érték megadása azt jelenti, hogy egy gyorsítót (két magot) használunk. Ez azt jelenti, hogy több dolgozót is létrehozhatunk a végpont átviteli sebességének növelése érdekében.
• opció.motor – Ez Pythonra van állítva, jelezve, hogy nem használunk más fordítókat, például a DeepSpeed-et vagy a Faster Transformert ehhez a tárhelyhez.

Hozd el a saját forgatókönyvedet

Ha saját egyéni következtetési szkriptet szeretne vinni, el kell távolítania a option.entryPoint ból ből serving.properties. Az LMI tároló ebben az esetben megkeresi a model.py fájl ugyanazon a helyen, mint a serving.properties és ezzel futtassa le a következtetést.

Készítse el saját következtetési szkriptjét (model.py)

Saját következtetési szkript létrehozása viszonylag egyszerű az LMI-tároló használatával. A konténer megköveteli az Ön model.py fájlt, hogy a következő módszer megvalósítása legyen:

def handle(inputs: Input) which returns an object of type Outputs

Vizsgáljuk meg a néhány kritikus területet csatolt jegyzetfüzet, amely bemutatja a hozza a saját script funkciót.

Cseréljük ki a cross_attention modul az optimalizált verzióval:

# Replace original cross-attention module with custom cross-attention module for better performance
    CrossAttention.get_attention_scores = get_attention_scores
Load the compiled weights for the following
text_encoder_filename = os.path.join(COMPILER_WORKDIR_ROOT, 'text_encoder.pt')
decoder_filename = os.path.join(COMPILER_WORKDIR_ROOT, 'vae_decoder.pt')
unet_filename = os.path.join(COMPILER_WORKDIR_ROOT, 'unet.pt')
post_quant_conv_filename =. os.path.join(COMPILER_WORKDIR_ROOT, 'vae_post_quant_conv.pt')

Ezek a lefordított súlyfájlok nevei, amelyeket a fordítások létrehozásakor használtunk. Nyugodtan módosíthatja a fájlneveket, de győződjön meg arról, hogy a súlyozási fájlnevek megegyeznek az itt megadottakkal.

Ezután be kell töltenünk őket a Neuron SDK segítségével, és be kell állítani őket a tényleges modellsúlyokba. Az UNet optimalizált súlyok betöltésekor vegye figyelembe, hogy megadjuk azoknak a Neuron magoknak a számát is, amelyekre ezeket be kell töltenünk. Itt egyetlen gyorsítóba töltünk be két maggal:

# Load the compiled UNet onto two neuron cores.
    pipe.unet = NeuronUNet(UNetWrap(pipe.unet))
    logging.info(f"Loading model: unet:created")
    device_ids = [idx for idx in range(tensor_parallel_degree)]
   
    pipe.unet.unetwrap = torch_neuronx.DataParallel(torch.jit.load(unet_filename), device_ids, set_dynamic_batching=False)
   
 
    # Load other compiled models onto a single neuron core.
 
    # - load encoders
    pipe.text_encoder = NeuronTextEncoder(pipe.text_encoder)
    clip_compiled = torch.jit.load(text_encoder_filename)
    pipe.text_encoder.neuron_text_encoder = clip_compiled
    #- load decoders
    pipe.vae.decoder = torch.jit.load(decoder_filename)
    pipe.vae.post_quant_conv = torch.jit.load(post_quant_conv_filename)

A következtetés prompttal történő futtatása meghívja a pipe objektumot egy kép létrehozásához.

Hozza létre a SageMaker végpontot

Boto3 API-kat használunk a SageMaker végpont létrehozásához. Hajtsa végre a következő lépéseket:

1. Készítse el a tarballt csak a tálalással és az opcionálissal model.py fájlokat, és töltse fel az Amazon S3-ra.
2. Hozza létre a modellt a képtároló és a korábban feltöltött modell tarball segítségével.
3. Hozza létre a végpont konfigurációját a következő kulcsparaméterekkel:
   1. Használja a ml.inf2.xlarge példa.
   2. Készlet ContainerStartupHealthCheckTimeoutInSeconds 240-re, hogy az állapotellenőrzés a modell üzembe helyezése után elinduljon.
   3. Készlet VolumeInGB nagyobb értékre, így a 32 GB méretű modellsúlyok betöltésére is használható.

Hozzon létre egy SageMaker modellt

Miután létrehozta a model.tar.gz fájlt, és feltöltötte az Amazon S3-ba, létre kell hoznunk egy SageMaker modellt. A SageMaker modell létrehozásához az előző lépésből származó LMI-tárolót és a modellműterméket használjuk. A SageMaker lehetővé teszi különböző környezeti változók testreszabását és beillesztését. Ehhez a munkafolyamathoz mindent alapértelmezettként hagyhatunk. Lásd a következő kódot:

inference_image_uri = (
    f"763104351884.dkr.ecr.{region}.amazonaws.com/djl-inference:0 djl-serving-inf2"
)

Hozzon létre egy modellobjektumot, amely lényegében egy zárolási tárolót hoz létre, amely betöltődik a példányba, és következtetésekhez használja:

model_name = name_from_base(f"inf2-sd")
create_model_response = boto3_sm_client.create_model(
    ModelName=model_name,
    ExecutionRoleArn=role,
    PrimaryContainer={"Image": inference_image_uri, "ModelDataUrl": s3_code_artifact},
)

Hozzon létre egy SageMaker végpontot

Ebben a bemutatóban egy ml.inf2.xlarge példányt használunk. Be kell állítanunk a VolumeSizeInGB paramétereket, hogy biztosítsák a szükséges lemezterületet a modell és a súlyok betöltéséhez. Ez a paraméter azokra a példányokra vonatkozik, amelyek támogatják a Amazon Elastic Block Store (Amazon EBS) kötetcsatlakozó. A modellletöltési időtúllépést és a konténer indítási állapotellenőrzését hagyhatjuk magasabb értékre, ami elegendő időt ad a konténernek, hogy kihúzza a súlyokat az Amazon S3-ból és betöltse az AWS Inferentia2 gyorsítókba. További részletekért lásd: Create EndpointConfig.

endpoint_config_response = boto3_sm_client.create_endpoint_config( EndpointConfigName=endpoint_config_name,
    ProductionVariants=[
        {
            "VariantName": "variant1",
            "ModelName": model_name,
            "InstanceType": "ml.inf2.xlarge", # - 
            "InitialInstanceCount": 1,
            "ContainerStartupHealthCheckTimeoutInSeconds": 360, 
            "VolumeSizeInGB": 400
        },
    ],
)

Végül létrehozunk egy SageMaker végpontot:

create_endpoint_response = boto3_sm_client.create_endpoint(
    EndpointName=f"{endpoint_name}", EndpointConfigName=endpoint_config_name
)

Hívja meg a modell végpontját

Ez egy generatív modell, ezért átadjuk azt a promptot, amelyet a modell a kép generálásához használ. A hasznos teher JSON típusú:

response_model = boto3_sm_run_client.invoke_endpoint( EndpointName=endpoint_name,
    Body=json.dumps(
        {
            "prompt": "Mountain Landscape", 
            "parameters": {} # 
        }
    ), 
    ContentType="application/json",
)

A stabil diffúziós modell összehasonlítása az Inf2-n

Néhány tesztet lefuttattunk a stabil diffúziós modell összehasonlítására a BF 16 adattípussal az Inf2-n, és képesek vagyunk olyan késleltetési számokat származtatni, amelyek vetekednek vagy meghaladják a stabil diffúzió más gyorsítóit. Ez az AWS Inferentia2 chipek alacsonyabb költségével párosulva rendkívül értékes ajánlattá teszi ezt.

A következő számok az inf2.xl példányon telepített Stable Diffusion modellből származnak. A költségekkel kapcsolatos további információkért lásd: Amazon EC2 Inf2 példányok.

Következtetés

Ebben a bejegyzésben a Stable Diffusion 2.1 modell összeállításában, optimalizálásában és telepítésében mutatkozunk be az Inf2 példányok használatával. Bemutattuk a Stable Diffusion modellek telepítését is a SageMaker segítségével. Az Inf2 példányok kiváló ár-teljesítményt is nyújtanak a Stable Diffusion 1.5-höz. Ha többet szeretne megtudni arról, hogy az Inf2-példányok miért kiválóak a generatív mesterséges intelligencia és a nagy nyelvi modellek számára, tekintse meg a következőt Az alacsony költségű, nagy teljesítményű generatív mesterséges intelligencia következtetések Amazon EC2 Inf2 példányai már általánosan elérhetőek. A teljesítmény részleteit lásd: Inf2 teljesítmény. Tekintse meg a további példákat a GitHub repo.

Külön köszönet Matthew Mclainnek, Beni Hegedusnak, Kamran Khannak, Shruti Koparkarnak és Qing Lannak az áttekintésért és az értékes hozzászólásokért.

A szerzőkről

Vivek Gangasani az Amazon Web Services vezető gépi tanulási megoldások építésze. Gépi tanulással foglalkozó induló vállalkozásokkal dolgozik, hogy AI/ML alkalmazásokat építsen és telepítsen AWS-en. Jelenleg az MLOp-k, az ML következtetések és az alacsony kódú ML megoldások szállítására összpontosít. Különféle területeken dolgozott projekteken, beleértve a természetes nyelvi feldolgozást és a számítógépes látást.

KC Tung az AWS Annapurna Labs vezető megoldástervezője. Szakterülete a nagy mélységű tanulási modellek képzése és a felhőben történő nagyszabású telepítés. Ph.D fokozata van. molekuláris biofizikában a Texasi Egyetem Délnyugati Orvosi Központjában, Dallasiban. Felszólalt az AWS Summits és az AWS Reinvent rendezvényeken. Ma segít ügyfeleinek a nagy PyTorch és TensorFlow modellek betanításában és üzembe helyezésében az AWS felhőben. Két könyv szerzője: Ismerje meg a TensorFlow Enterprise-t és a TensorFlow 2 Pocket Reference.

Rupinder Grewal Sr Ai/ML Specialist Solutions Architect, az AWS-vel. Jelenleg a SageMaker modellek és MLOp-k kiszolgálására összpontosít. Ezt megelőzően gépi tanulási mérnökként dolgozott modellek építésében és üzemeltetésében. Munkán kívül szeret teniszezni és hegyi ösvényeken kerékpározni.

• SEO által támogatott tartalom és PR terjesztés. Erősödjön még ma.
• PlatoData.Network Vertical Generative Ai. Erősítse meg magát. Hozzáférés itt.
• PlatoAiStream. Web3 Intelligence. Felerősített tudás. Hozzáférés itt.
• PlatoESG. Autóipar / elektromos járművek, Carbon, CleanTech, Energia, Környezet, Nap, Hulladékgazdálkodás. Hozzáférés itt.
• BlockOffsets. A környezetvédelmi ellentételezési tulajdon korszerűsítése. Hozzáférés itt.
• Forrás: https://aws.amazon.com/blogs/machine-learning/maximize-stable-diffusion-performance-and-lower-inference-costs-with-aws-inferentia2/