מקסם את ביצועי הדיפוזיה היציבים והורד את עלויות ההסקה עם AWS Inferentia2 | שירותי האינטרנט של אמזון

דגמי AI גנרטיביים חווים צמיחה מהירה בחודשים האחרונים בשל היכולות המרשימות שלהם ביצירת טקסט, תמונות, קוד ואודיו מציאותיים. בין הדגמים הללו, דגמי Stable Diffusion בולטים בחוזקם הייחודי ביצירת תמונות באיכות גבוהה המבוססים על הנחיות טקסט. דיפוזיה יציבה יכולה ליצור מגוון רחב של תמונות באיכות גבוהה, כולל פורטרטים ריאליסטיים, נופים ואפילו אמנות מופשטת. וכמו דגמי AI מחוללים אחרים, מודלים של דיפוזיה יציבה דורשים מחשוב רב עוצמה כדי לספק הסקת השהייה נמוכה.

בפוסט זה, אנו מראים כיצד ניתן להפעיל מודלים של דיפוזיה יציבה ולהשיג ביצועים גבוהים בעלות הנמוכה ביותר ב ענן מחשוב אלסטי של אמזון (Amazon EC2) באמצעות מקרים של אמזון EC2 Inf2 מופעל על ידי AWS Inferentia2. אנו מסתכלים על הארכיטקטורה של מודל דיפוזיה יציבה ועוברים את השלבים של הרכבת מודל דיפוזיה יציבה באמצעות AWS נוירון ופריסה למופע Inf2. אנו גם דנים באופטימיזציות ש- Neuron SDK מבצע אוטומטית לשיפור הביצועים. אתה יכול להריץ הן גרסאות Stable Diffusion 2.1 ו-1.5 ב-AWS Inferentia2 בצורה חסכונית. לבסוף, אנו מראים כיצד ניתן לפרוס מודל Diffusion Stable למופע Inf2 עם אמזון SageMaker.

גודל הדגם Stable Diffusion 2.1 בנקודה צפה 32 (FP32) הוא 5 GB ו-2.5 GB ב-bfoat16 (BF16). למופע יחיד של inf2.xlarge יש מאיץ AWS Inferentia2 אחד עם זיכרון HBM של 32 GB. דגם Stable Diffusion 2.1 יכול להתאים למופע יחיד של inf2.xlarge. Stable Diffusion הוא מודל טקסט לתמונה שבו אתה יכול להשתמש כדי ליצור תמונות של סגנונות ותוכן שונים פשוט על ידי מתן הנחית טקסט כקלט. למידע נוסף על ארכיטקטורת מודל הדיפוזיה היציבה, עיין ב צור תמונות באיכות גבוהה עם מודלים של דיפוזיה יציבה ופרוס אותן בצורה חסכונית עם Amazon SageMaker.

כיצד Neuron SDK מייעל את ביצועי ה-Stable Diffusion

לפני שנוכל לפרוס את המודל Stable Diffusion 2.1 במופעי AWS Inferentia2, עלינו להרכיב את רכיבי המודל באמצעות Neuron SDK. ה- Neuron SDK, הכולל מהדר למידה עמוקה, זמן ריצה וכלים, מקמפל ומייעל מודלים של למידה עמוקה באופן אוטומטי כדי שיוכלו לפעול ביעילות על מופעי Inf2 ולחלץ את הביצועים המלאים של מאיץ ה-AWS Inferentia2. יש לנו דוגמאות זמינות עבור דגם Stable Diffusion 2.1 על GitHub ריפו. מחברת זו מציגה דוגמה מקצה לקצה כיצד להרכיב מודל דיפוזיה יציבה, לשמור את דגמי ה- Neuron שהורכבו ולטעון אותו לזמן הריצה לצורך הסקה.

אנו משתמשים StableDiffusionPipeline מהפנים המחבקות diffusers ספרייה כדי לטעון ולהדר את המודל. לאחר מכן אנו מרכיבים את כל רכיבי המודל עבור Neuron באמצעות torch_neuronx.trace() ושמור את המודל המותאם בתור TorchScript. תהליכי הידור יכולים להיות די עתירי זיכרון, ודורשים כמות משמעותית של זיכרון RAM. כדי לעקוף זאת, לפני מעקב אחר כל דגם, אנו יוצרים א deepcopy של החלק בצינור שנמצא במעקב. לאחר מכן, אנו מוחקים את אובייקט הצינור מהזיכרון באמצעות del pipe. טכניקה זו שימושית במיוחד בעת קומפילציה במופעים עם זיכרון RAM נמוך.

בנוסף, אנו גם מבצעים אופטימיזציות למודלים של דיפוזיה יציבה. UNet מחזיק בהיבט האינטנסיבי ביותר מבחינה חישובית של ההסקה. רכיב ה-UNet פועל על טנסור קלט שיש להם גודל אצווה של שניים, ומייצר טנזור פלט מתאים גם עם גודל אצווה של שניים, כדי לייצר תמונה בודדת. האלמנטים בתוך אצוות אלה אינם תלויים לחלוטין זה בזה. אנו יכולים לנצל את ההתנהגות הזו כדי לקבל חביון אופטימלי על ידי הפעלת אצווה אחת על כל ליבת נוירון. אנו מרכיבים את UNet עבור אצווה אחת (על ידי שימוש בטנסורי קלט עם אצווה אחת), ולאחר מכן משתמשים ב- torch_neuronx.DataParallel API לטעינת מודל אצווה בודד זה על כל ליבה. הפלט של ממשק API זה הוא מודול חלק של שתי אצווה: אנו יכולים להעביר ל-UNet את התשומות של שתי אצווה, ופלט שתי אצווה מוחזר, אך באופן פנימי, שני הדגמים הבודדים פועלים על שתי ליבות Neuron . אסטרטגיה זו מייעלת את ניצול המשאבים ומפחיתה את זמן האחזור.

קומפל ופרוס מודל Diffusion Stable על מופע Inf2 EC2

כדי להרכיב ולפרוס את מודל ה-Stable Diffusion במופע Inf2 EC2, היכנס ל- קונסולת הניהול של AWS וליצור מופע inf2.8xlarge. שימו לב שמופע inf2.8xlarge נדרש רק עבור הידור של המודל מכיוון שהקומפילציה דורשת זיכרון מארח גבוה יותר. ניתן לארח את מודל ה-Stable Diffusion במופע inf2.xlarge. אתה יכול למצוא את ספריות AMI העדכניות ביותר עם Neuron באמצעות הדברים הבאים ממשק שורת הפקודה של AWS (AWS CLI) פקודה:

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

עבור דוגמה זו, יצרנו מופע EC2 באמצעות Deep Learning AMI Neuron PyTorch 1.13 (Ubuntu 20.04). לאחר מכן תוכל ליצור סביבת מעבדה של JupyterLab על ידי חיבור למופע והפעלת השלבים הבאים:

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

מחברת עם כל השלבים להידור ואירוח הדגם ממוקמת עליה GitHub.

הבה נסתכל על שלבי ההידור עבור אחד מבלוקים מקודד הטקסט. בלוקים אחרים שהם חלק מצינור ה-Stable Diffusion ניתן להרכיב באופן דומה.

הצעד הראשון הוא לטעון את הדגם שהוכשר מראש מבית Hugging Face. ה StableDiffusionPipeline.from_pretrained השיטה טוענת את המודל שהוכשר מראש לאובייקט הצינור שלנו, pipe. לאחר מכן אנו יוצרים א deepcopy של מקודד הטקסט מהצינור שלנו, שיבוט אותו ביעילות. ה del pipe הפקודה משמשת לאחר מכן למחיקת אובייקט הצינור המקורי, תוך שחרור הזיכרון שנצרך על ידו. כאן, אנו מכמתים את המודל למשקולות BF16:

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

שלב זה כרוך לעטוף את מקודד הטקסט שלנו ב- NeuronTextEncoder עֲטִיפָה. הפלט של מודול מקודד טקסט הידור יהיה של dict. אנחנו ממירים אותו ל-a list הקלד באמצעות העטיפה הזו:

text_encoder = NeuronTextEncoder(text_encoder)

אנו מאתחלים את PyTorch tensor emb עם כמה ערכים. ה emb טנסור משמש כקלט לדוגמה עבור torch_neuronx.trace פוּנקצִיָה. פונקציה זו עוקבת אחר מקודד הטקסט שלנו ומרכיבה אותו לפורמט מותאם ל- Neuron. נתיב הספרייה עבור המודל המהודר נבנה על ידי הצטרפות COMPILER_WORKDIR_ROOT עם ספריית המשנה 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'),
        )

מקודד הטקסט המהודר נשמר באמצעות torch.jit.save. זה מאוחסן תחת שם הקובץ model.pt ב- text_encoder ספריית סביבת העבודה של המהדר שלנו:

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

השמיים מחברה כולל שלבים דומים להידור רכיבים אחרים של המודל: UNet, מפענח VAE ו-VAE post_quant_conv. לאחר שהרכבת את כל הדגמים, תוכל לטעון ולהפעיל את המודל לפי השלבים הבאים:

1. הגדירו את הנתיבים עבור המודלים שהורכבו.
2. טען אימון מראש StableDiffusionPipeline מודל, עם התצורה שלו שצוינה לשימוש בסוג הנתונים bfloat16.
3. טען את מודל UNet על שתי ליבות Neuron באמצעות ה torch_neuronx.DataParallel ממשק API. זה מאפשר לבצע הסקת נתונים מקבילים, מה שיכול להאיץ משמעותית את ביצועי המודל.
4. טען את שאר החלקים של הדגם (text_encoder, decoder, ו post_quant_conv) על ליבת נוירון אחת.

לאחר מכן תוכל להפעיל את הצינור על ידי מתן טקסט קלט כהנחיות. להלן כמה תמונות שנוצרו על ידי המודל עבור ההנחיות:

• דיוקן של רנאוד סשהאן, עט ודיו, ציורי קו מורכבים, מאת קרייג מולינס, רואן ג'יה, קנטארו מיורה, גרג רוטקובסקי, לונדרו

• דיוקן של כורה פחם זקן במאה ה-19, ציור יפהפה, עם ציור פנים מפורט מאוד מאת גרג רוטקובסקי

• טירה באמצע יער

מארח Stable Diffusion 2.1 ב-AWS Inferentia2 ו- SageMaker

אירוח דגמי Diffusion Stable עם SageMaker דורש גם קומפילציה עם Neuron SDK. אתה יכול להשלים את הקומפילציה לפני הזמן או בזמן ריצה באמצעות מיכלי Large Model Inference (LMI). קומפילציה מבעוד מועד מאפשרת זמני טעינת דגמים מהירים יותר והיא האפשרות המועדפת.

מכולות SageMaker LMI מספקות שתי דרכים לפרוס את המודל:

• אפשרות ללא קוד שבה אנו רק מספקים א serving.properties קובץ עם התצורות הנדרשות
• תביא תסריט מסקנות משלך

אנו מסתכלים על שני הפתרונות ועוברים על התצורות ועל סקריפט ההסקה (model.py). בפוסט זה, אנו מדגימים את הפריסה באמצעות מודל הידור מראש המאוחסן ב-an שירות אחסון פשוט של אמזון דלי (Amazon S3). אתה יכול להשתמש במודל זה מראש עבור הפריסות שלך.

הגדר את המודל עם סקריפט שסופק

בסעיף זה, אנו מראים כיצד להגדיר את מיכל ה-LMI לארח את דגמי הדיפוזיה היציבה. המחברת SD2.1 זמינה ב GitHub. השלב הראשון הוא ליצור את חבילת תצורת המודל לפי מבנה הספריות הבא. המטרה שלנו היא להשתמש בתצורות המודל המינימליות הדרושות לאירוח הדגם. מבנה הספריות הדרוש הוא כדלקמן:

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

לאחר מכן, אנו יוצרים את הגשה.נכסים קובץ עם הפרמטרים הבאים:

%%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

הפרמטרים מציינים את הדברים הבאים:

• option.model_id – מיכלי ה-LMI משתמשים ב-s5cmd כדי לטעון את הדגם ממיקום ה-S3 ולכן עלינו לציין את המיקום של המשקולות שלנו.
• option.entryPoint – כדי להשתמש במטפלים המובנים, אנו מציינים את מחלקת transformers-neuronx. אם יש לך סקריפט מסקנות מותאם אישית, עליך לספק זאת במקום זאת.
• option.dtype - זה מציין לטעון את המשקולות בגודל מסוים. עבור פוסט זה, אנו משתמשים ב-BF16, אשר מקטין עוד יותר את דרישות הזיכרון שלנו לעומת FP32 ומוריד את זמן ההשהיה שלנו בשל כך.
• option.tensor_parallel_degree – פרמטר זה מציין את מספר המאיצים שאנו משתמשים בדגם זה. למאיץ שבב AWS Inferentia2 יש שתי ליבות Neuron, ולכן ציון ערך של 2 אומר שאנו משתמשים במאיץ אחד (שתי ליבות). זה אומר שאנחנו יכולים ליצור כעת מספר עובדים כדי להגדיל את התפוקה של נקודת הקצה.
• מנוע אפשרות - זה מוגדר לפייתון כדי לציין שלא נשתמש במהדרים אחרים כמו DeepSpeed ​​או Faster Transformer עבור אירוח זה.

תביא תסריט משלך

אם אתה רוצה להביא סקריפט מסקנות מותאם אישית משלך, עליך להסיר את option.entryPoint החל מ- serving.properties. מיכל LMI במקרה כזה יחפש א model.py קובץ באותו מיקום כמו ה- serving.properties ולהשתמש בזה כדי להפעיל את ההסקה.

צור סקריפט מסקנות משלך (model.py)

יצירת סקריפט מסקנות משלך היא פשוטה יחסית באמצעות מיכל ה-LMI. המכולה דורשת שלך model.py ליישום של השיטה הבאה:

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

הבה נבחן כמה מהתחומים הקריטיים של מחברת מצורפת, המדגים את פונקציית הבא תסריט משלך.

החלף את cross_attention מודול עם הגרסה המותאמת:

# 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')

אלו הם השמות של קובץ המשקולות המלוקט בהן השתמשנו בעת יצירת ההידורים. אל תהסס לשנות את שמות הקבצים, אך וודא ששמות קבצי המשקולות שלך תואמים למה שאתה מציין כאן.

אז אנחנו צריכים לטעון אותם באמצעות Neuron SDK ולהגדיר אותם במשקלי הדגם בפועל. בעת טעינת המשקולות האופטימליות של UNet, שימו לב שאנו מציינים גם את מספר ליבות הנוירון שעליהן אנו צריכים לטעון. כאן, אנו טוענים למאיץ יחיד עם שתי ליבות:

# 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)

הפעלת ההסקה עם הנחיה מפעילה את אובייקט הצינור כדי ליצור תמונה.

צור את נקודת הקצה של SageMaker

אנו משתמשים בממשקי API של Boto3 כדי ליצור נקודת קצה של SageMaker. השלם את השלבים הבאים:

1. יוצרים את הטארבול רק עם ההגשה והאופציונלי model.py קבצים והעלה אותם לאמזון S3.
2. צור את המודל באמצעות מיכל התמונה ו-tarball של הדגם שהועלה קודם לכן.
3. צור את תצורת נקודת הקצה באמצעות הפרמטרים המרכזיים הבאים:
   1. השתמש ב- ml.inf2.xlarge למשל.
   2. לקבוע ContainerStartupHealthCheckTimeoutInSeconds ל-240 כדי להבטיח שבדיקת התקינות מתחילה לאחר פריסת המודל.
   3. לקבוע VolumeInGB לערך גדול יותר כך שניתן להשתמש בו לטעינת משקלי הדגם בגודל 32 GB.

צור מודל של SageMaker

לאחר שתיצור את הקובץ model.tar.gz והעלה אותו לאמזון S3, עלינו ליצור מודל של SageMaker. אנו משתמשים במיכל ה-LMI ובחפץ המודל מהשלב הקודם כדי ליצור את מודל SageMaker. SageMaker מאפשר לנו להתאים אישית ולהחדיר משתני סביבה שונים. עבור זרימת עבודה זו, אנו יכולים להשאיר הכל כברירת מחדל. ראה את הקוד הבא:

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

צור את אובייקט הדגם, שבעצם יוצר מיכל נעילה שנטען על המופע ומשמש להסקת מסקנות:

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},
)

צור נקודת קצה של SageMaker

בהדגמה זו, אנו משתמשים במופע ml.inf2.xlarge. אנחנו צריכים להגדיר את VolumeSizeInGB פרמטרים כדי לספק את שטח הדיסק הדרוש לטעינת הדגם והמשקולות. פרמטר זה חל על מופעים התומכים ב- חנות בלוקים אלסטית של אמזון (Amazon EBS) חיבור לנפח. נוכל להשאיר את פסק הזמן של הורדת הדגם ובדיקת תקינות ההפעלה של המכולה לערך גבוה יותר, מה שייתן זמן הולם למכולה למשוך את המשקולות מאמזון S3 ולהיטען לתוך מאיצי ה-AWS Inferentia2. לפרטים נוספים, עיין ב CreateEndpointConfig.

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
        },
    ],
)

לבסוף, אנו יוצרים נקודת קצה של SageMaker:

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

הפעל את נקודת הקצה של הדגם

זהו מודל מחולל, אז אנו מעבירים את ההנחיה שהמודל משתמש בה כדי ליצור את התמונה. המטען הוא מסוג JSON:

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

השוואת מודל ה-Stable Diffusion ב-Inf2

הרצנו כמה בדיקות כדי למדוד את מודל הדיפוזיה היציבה עם סוג הנתונים BF 16 ב-Inf2, ואנו מסוגלים לגזור מספרי חביון שמתחרים או עולים על כמה מהמאיצים האחרים עבור דיפוזיה יציבה. זה, יחד עם העלות הנמוכה יותר של שבבי AWS Inferentia2, הופכים את זה להצעה בעלת ערך רב.

המספרים הבאים הם ממודל ה-Stable Diffusion שנפרס על מופע inf2.xl. למידע נוסף על עלויות, עיין ב מופעי EC2 Inf2 של אמזון.

סיכום

בפוסט זה, שקענו עמוק לתוך ההידור, האופטימיזציה והפריסה של מודל Stable Diffusion 2.1 באמצעות מופעי Inf2. הדגמנו גם פריסה של מודלים של דיפוזיה יציבה באמצעות SageMaker. מופעי Inf2 מספקים גם ביצועי מחיר מעולים עבור Stable Diffusion 1.5. למידע נוסף על מדוע מופעי Inf2 מעולים עבור AI גנרטיבי ומודלים של שפות גדולות, עיין ב מופעי אמזון EC2 Inf2 עבור מסקנות בינה מלאכותית מחוללת בעלות נמוכה ובעל ביצועים גבוהים זמינים כעת בדרך כלל. לפרטי ביצועים, עיין ב Inf2 ביצועים. בדוק דוגמאות נוספות ב- GitHub ריפו.

תודה מיוחדת למת'יו מקליין, בני הגדוס, קמראן חאן, שרוטי קופארקאר וצ'ינג לאן על הביקורת והספקת תשומות חשובות.

על הכותבים

Vivek Gangasani הוא ארכיטקט בכיר של פתרונות למידת מכונה בשירותי האינטרנט של אמזון. הוא עובד עם סטארט-אפים של למידת מכונה כדי לבנות ולפרוס יישומי AI/ML ב-AWS. כיום הוא מתמקד באספקת פתרונות עבור MLOps, ML inference ו-ML בקוד נמוך. הוא עבד על פרויקטים בתחומים שונים, כולל עיבוד שפה טבעית וראייה ממוחשבת.

KC טונג הוא ארכיטקט פתרונות בכיר במעבדות AWS Annapurna. הוא מתמחה בהדרכה ובפריסה של מודלים גדולים של למידה עמוקה בקנה מידה בענן. יש לו דוקטורט. בביופיזיקה מולקולרית מהמרכז הרפואי הדרום-מערבי של אוניברסיטת טקסס בדאלאס. הוא דיבר ב-AWS Summits וב-AWS Reinvent. כיום הוא עוזר ללקוחות להכשיר ולפרוס דגמי PyTorch ו-TensorFlow גדולים בענן AWS. הוא מחברם של שני ספרים: למד את TensorFlow Enterprise ו TensorFlow 2 Pocket Reference.

רופנדר גרוואל הוא אדריכל פתרונות מומחה Sr Ai/ML עם AWS. כיום הוא מתמקד בהגשת דגמים ו-MLOps ב- SageMaker. לפני תפקיד זה עבד כמהנדס למידת מכונה בבניית ואירוח מודלים. מחוץ לעבודה הוא נהנה לשחק טניס ולרכוב על אופניים בשבילי הרים.

• הפצת תוכן ויחסי ציבור מופעל על ידי SEO. קבל הגברה היום.
• PlatoData.Network Vertical Generative Ai. העצים את עצמך. גישה כאן.
• PlatoAiStream. Web3 Intelligence. הידע מוגבר. גישה כאן.
• PlatoESG. רכב / רכבים חשמליים, פחמן, קלינטק, אנרגיה, סביבה, שמש, ניהול פסולת. גישה כאן.
• BlockOffsets. מודרניזציה של בעלות על קיזוז סביבתי. גישה כאן.
• מקור: https://aws.amazon.com/blogs/machine-learning/maximize-stable-diffusion-performance-and-lower-inference-costs-with-aws-inferentia2/