כדי להטמיע משפחת דגמי Lama באמצעות NVIDIA NIM במחשב הענן או במכונה המקומית שלך, פעל לפי השלבים הבאים:

1. הגדר את הסביבה: אם אתה מריץ על המחשב המקומי שלך, התקן את מנוע Docker והערכת הכלים של NVIDIA. קישורים לאלה מסופקים בתיאור הווידאו.

2. קבל מפתח API: הירשם לחשבון NVIDIA כדי ליצור את מפתח ה-API והמפתח האישי שלך. אלה יידרשו לאינטראקציה עם השרת המרוחק.

3. הרץ את מכל Docker: השתמש בפקודת Docker המסופקת כדי להריץ את המכל, תוך ציון שם המכל, שימוש ב-GPU, מפתח ה-API, מיקום מטמון הדגם והפורט. זה יורידו ויגדיר את דגם Lama 3 8 מיליארד הוראות.

4. אינטראקציה עם הדגם: השתמש בפקודת cURL המסופקת כדי להתקשר עם הדגם המוטמע. פקודה זו עוקבת אחר תקן ה-OpenAI API, מאפשרת לך להשתמש בלקוח ה-OpenAI לאינטראקציה.

5. בדוק את העומס על ה-API: השתמש בסקריפט Python עם הספרייה requests כדי לשלוח בקשות מקבילות רבות לקצה הקצה של ה-API ולנטר את ניצול ה-GPU והתפוקה.

6. השתמש בלקוח ה-API של OpenAI: הדגם כיצד להשתמש בלקוח ה-API של OpenAI עם NVIDIA NIM, על-ידי עדכון כתובת ה-URL הבסיסית וכל שאר הפרמטרים כדי להתאים לדגם המוטמע.

NVIDIA NIM מספק דרך נוחה ומאופטמת להטמיע דגמי שפה גדולים לצורך הסקה, עם היכולת להשיג ביצועים טובים עד 3 פעמים יותר בהשוואה לאפשרויות הטמעה אחרות. הניסיון החינמי ל-90 ימים מאפשר לך לחקור את הפתרון הזה עוד יותר.

כדי לגשת ללוח המחוונים של NVIDIA Launchpad ושל מדדי ה-GPU, פעל לפי השלבים הבאים:

1. כחלק מ-NVIDIA Launchpad, אתה מקבל גישה לסביבת פיתוח קוד, שהיא Visual Studio Code. אתה יכול להשתמש בסביבה זו כדי להתקשר עם מופע ה-GPU ולהטמיע את דגם Llama 3 8 מיליארד הוראות.

2. לוח המחוונים של מדדי ה-GPU הוא לוח מחוונים של Grafana המספק מידע מפורט על שימוש ב-GPU וביצועים. אתה יכול לגשת ללוח מחוונים זה כדי לנטר את ניצול ה-GPU, גרסת CUDA, מנהלי ההתקן של ה-GPU ומדדים רלוונטיים אחרים.

3. לוח המחוונים של Grafana מספק ייצוג חזותי של ניצול ה-GPU לאורך זמן, מאפשר לך לעקוב אחר הביצועים ולאופטם את ההטמעה בהתאם.

4. אתה יכול להשתמש בפקודת watch בטרמינל כדי לנטר את ניצול ה-GPU בזמן אמת. הפקודה watch -n 1 nvidia-smi תעדכן את ניצול ה-GPU מדי שנייה, ותספק לך תצוגה חיה של ניצול ה-GPU.

5. לוח המחוונים של מדדי ה-GPU והכלים לניטור בזמן אמת מאפשרים לך להבין את מאפייני הביצועים של הטמעת דגם Llama 3 8 מיליארד הוראות, ומסייעים לך לאופטם את ניצול המשאבים ולהבטיח הסקה יעילה.

כדי להטמיע את דגם Llama 3 8 מיליארד הוראות באמצעות NVIDIA NIM, פעל לפי השלבים הבאים:

1. פתח את סביבת הפיתוח הקוד המסופקת וודא שיש לך גישה ל-GPU מסוג H100.
2. הגדר את מפתח ה-API על-ידי הרשמה לחשבון NVIDIA וייצור המפתחות הנדרשים.
3. הרץ את הפקודת Docker הבאה כדי להפעיל את מכל NVIDIA NIM:

docker run -it --gpus all -e NVIDIA_API_KEY=$NVIDIA_API_KEY -p 8000:8000 --name llama-3-8b-instruct nvcr.io/nvidia/nim:latest --model-name llama-3-8b-instruct

פקודה זו תעשה את הפעולות הבאות:

• יצור מכל Docker בשם "llama-3-8b-instruct"
• ישתמש בכל ה-GPU הזמינים במערכת
• יגדיר את משתנה הסביבה NVIDIA_API_KEY
• יחשוף את הפורט 8000 עבור שרת ה-NIM
• ישתמש בדגם "llama-3-8b-instruct" מקטלוג NVIDIA NIM

4. לאחר הפעלת המכל, אתה יכול להשתמש בפקודת cURL המסופקת כדי להתקשר עם הדגם:

curl -X POST -H "Content-Type: application/json" -d '{"model": "llama-3-8b-instruct", "prompt": "Tell me a joke.", "max_tokens": 1000, "temperature": 0.7, "top_p": 0.95, "stop": ["\n"]}' http://localhost:8000/v1/completions

פקודת cURL זו שולחת בקשה לשרת ה-NIM המריץ על localhost:8000 כדי לייצר תגובה לפרומפט "Tell me a joke.".

5. כדי לבדוק את העומס על קצה הקצה של ה-API, אתה יכול להריץ את הסקריפט Python test_server.py המסופק. סקריפט זה ישלח בקשות מקבילות רבות לשרת ה-NIM ויעקוב אחר ניצול ה-GPU.

6. לבסוף, אתה יכול גם להשתמש בלקוח ה-API של OpenAI כדי להתקשר עם שרת ה-NIM על-ידי עדכון כתובת ה-URL הבסיסית כך שתצביע על כתובת ופורט שרת ה-NIM.

על-ידי ביצוע השלבים האלה, אתה יכול להטמיע בהצלחה את דגם Llama 3 8 מיליארד הוראות באמצעות מכל Docker של NVIDIA NIM ולבדוק את ביצועיו.

כדי להתקשר עם ה-API של NVIDIA NIM, אנו יכולים להשתמש בפקודת cURL פשוטה. פקודת cURL מספקת את הפונקציונליות הבאה:

• מבצעת בקשת POST לכתובת המקומית בפורט 8000, שם שרת ה-NVIDIA NIM מריץ.
• משתמשת בממשק התואם ל-OpenAI API, כך שנוכל להשתמש בלקוח ה-OpenAI כדי להתקשר עם שרת ה-NIM.
• מציינת את דגם Llama 3 8 מיליארד ההוראות לשימוש.
• מגדירה את מבנה ההודעה בדומה למה שמצופה מ-OpenAI.
• מאפשרת להגדיר פרמטרים נוספים כמו max_tokens ו-temperature.

הנה פקודת ה-cURL:

curl -X POST -H "Content-Type: application/json" -d '{"model": "nlp/lama-3-8b-instruct", "messages": [{"role": "user", "content": "Tell me a joke"}], "max_tokens": 1000, "temperature": 0.7}' http://localhost:8000/v1/chat/completions

פקודת cURL זו תשלח בקשה לשרת NVIDIA NIM, אשר יייצר תגובה מדגם Llama 3 8 מיליארד ההוראות. התגובה תוזרם בחזרה, כאשר כל אסימון יוצג ברגע שהוא מיוצר.

כדי לבדוק את העומס על קצה הקצה של ה-API עוד יותר, אנו יכולים להשתמש בסקריפט Python המשתמש בספרייה requests כדי לשלוח בקשות מקבילות רבות. סקריפט זה ישלח 50 בקשות לייצור בדיחות במקביל ויעקוב אחר ניצול ה-GPU והתפוקה.

import requests
import threading

url = "http://localhost:8000/v1/chat/completions"
headers = {"Content-Type": "application/json"}
payload = {
    "model": "nlp/lama-3-8b-instruct",
    "messages": [{"role": "user", "content": "Tell me 50 jokes"}],
    "max_tokens": 1000,
    "temperature": 0.7,
    "stream": False
}

def send_requests():
    for _ in range(50):
        response = requests.post(url, headers=headers, json=payload)
        print(response.json())

threads = []
for _ in range(10):
    t = threading.Thread(target=send_requests)
    t.start()
    threads.append(t)

for thread in threads:
    thread.join()

סקריפט זה מדגים כיצד להשתמש בממשק התואם ל-OpenAI API עם שרת NVIDIA NIM. הוא מראה ששרת NVIDIA NIM יכול לספק הסקה בביצועים גבוהים עבור דגמי שפה גדולים, עם פוטנציאל לשיפור של עד 3 פעמים בהשוואה לאפשרויות הטמעה אחרות.

כדי לבדוק את העומס על קצה הקצה של ה-API של NVIDIA NIM, נשתמש בסקריפט Python פשוט המנצל את הספרייה requests כדי לשלוח בקשות מקבילות רבות לקצה הקצה. הנה כיצד זה עובד:

1. אנו מגדירים את כתובת קצה ה-API, שבמקרה הזה היא המחשב המקומי מאחר שאנו מריצים את השרת באופן מקומי. אם היית מטמיע זאת על שרת מרוחק, היית צריך להשתמש בכתובת ה-IP החיצונית ולאפשר העברת פורטים.

2. אנו מגדירים את הכותרות הנדרשות, כולל הכותרת Content-Type להיות application/json.

3. אנו יוצרים את ה-payload, הכולל את שם הדגם ("model": "llama-3-8b-instruct"), את הפרומפט ("prompt": "Tell me 50 jokes."), ופרמטרים אחרים כמו max_tokens, temperature ו-stop.

4. אנו מגדירים פונקציה send_requests() שמשלחת את הבקשות באמצעות requests.post() ואת ה-URL, הכותרות וה-payload שהגדרנו קודם.

5. אנו משתמשים בריבוי חוטים כדי להריץ מספר עותקים של הפונקציה send_requests() במקביל, מדמים נפח גבוה של בקשות לקצה הקצה של ה-API.

6. אנו עוקבים אחר ניצול ה-GPU בזמן אמת באמצעות הפקודה watch והכלי `