כיצד לאינטגרציה של מודלי OpenAI GPT בפרויקט Django שלך

המחבר בחר ב־ תוכנית הסיוע הישיר כדי לקבל תרומה כחלק מתוכנית כתוב עבור תרומות.

הקדמה

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

מודלים אלו של GPT נעשה בכלל שימוש באמצעות ChatGPT, רובוט צ'אט ששוחרר על ידי OpenAI, או דרך API וספריות המספקות שליטה גדולה יותר. במדריך זה תלמד כיצד להשתמש במודלים אלו באמצעות ה־API של OpenAI בתוך פרויקט ה־web שלך ב־Django. תלמד כיצד לקרוא ל־API ChatCompletion בשימוש בפרמטרים שונים וכיצד לפרמט ולהשתמש בתגובות שלו.

עד סוף המדריך הזה, תיצור נקודת סיום ב־Django שמתקבלת בקריאה, שולחת בקשה ל־OpenAI לבנות סיפור קצר באמצעות המילים המסופקות ומחזירה את התגובה שלו.

דרישות מוקדמות

כדי להשלים את המדריך הזה, תצטרך:

1. פרוייקט Django קיים. אם אתה מתחיל מאפס, תוכל להגדיר פרוייקט Django על ידי מעקב אחרי המדריך איך להגדיר סביבת פיתוח Django.

2. חשבון OpenAI: עבור אל אתר פלטפורמת OpenAI וחפש את כפתור 'הרשם'. לאחר ההרשמה, עליך לאמת את כתובת האימייל שלך ולהזין מידע אישי.

3. מפתח API של OpenAI: לאחר שהחשבון שלך מוכן, התחבר ונווט אל מפתחי API מהלוח שלך. לחץ על 'צור מפתח סודי חדש'. המפתח שלך ייוצר ויראה משהו כמו sk-abcdefghijklmnop. ודא כי אתה שומר את המפתח הזה במקום מאובטח, מכיוון שלא תוכל לראות אותו שוב.

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

sammy@ubuntu:$ .env/bin/activate

במקום הסביבה מתוך הספרייה django-apps. לאחר שהסביבה שלך פעילה, הרץ את הפקודה הבאה כדי להתקין את חבילת ה-Python של OpenAI:

(env)sammy@ubuntu:$ pip install openai

שלב 1 — הפקת קריאות ל-OpenAI

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

כדי להתחיל, פתחו את ממשק ה-Python שלכם:

(env)sammy@ubuntu:$ python

ראשית, יבאו את הלקוח של OpenAI ותוסיפו את מפתח ה- API שלכם ללקוח:

from openai import OpenAI
client = OpenAI(api_key="your-api-key")

החליפו את "your-api-key" במפתח ה- API האמיתי שקיבלתם מפלטפורמת OpenAI.

עכשיו, בואו נבצע קריאת API ל- ChatCompletion API. השתמשו בשיטת chat.completions.create():

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "count 1 to 10"}])

בקוד לעיל, הגדרנו את ה- מודל שיש להשתמש כ- gpt-3.5-turbo, הוספנו אובייקט הודעה יחידה המכילה את התפקיד user (אפשרויות אחרות הן system ו- assistant) ואת התוכן / הפרומט count 1 to 10.

כדי לראות את התגובה מהקריאה ל- API, תוכלו להדפיס את ההודעה של התגובה, שצריכה לכלול את המספרים 1 עד 10 ברשימה נחמדה:

print(response.choices[0].message.content)

פלט:

Output
1, 2, 3, 4, 5, 6, 7, 8, 9, 10

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

שלב 2 — עבודה עם פרמטרים

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

1. טמפרטורה: פרמטר הטמפרטורה קובע כמה רנדומלי התוכן שנוצר. ערך טמפרטורה גבוה, כמו 0.8, יגרום לתגובות יותר מגוונות ויצירתיות, בעוד שערך נמוך של טמפרטורה, כמו 0.1, יייצר תגובות דומות יותר. לדוגמה:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], temperature=0.1)
print(response.choices[0].message.content)

Output
1. Apple
2. Elephant
3. Sunshine
4. Adventure
5. Serenity

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

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], temperature=0.1)
print(response.choices[0].message.content)

Output
1. Apple
2. Elephant
3. Sunshine
4. Adventure
5. Serenity

הטקסט יצא זהה. עכשיו, בואו ננסה טמפרטורה=0.8 פעמיים:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], temperature=0.8)
print(response.choices[0].message.content)
cat, apple, guitar, sky, book
response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], temperature=0.8)
print(response.choices[0].message.content)

Output
1. Apple
2. Sunshine
3. Happiness
4. Love
5. Technology

2. מקסימום טוקנים: זה מאפשר לך להגביל את אורך הטקסט שנוצר. הגדרת ערך מסוים מבטיחה שהתגובה לא תחרוג ממספר מסוים של טוקנים. טוקנים מתאימים למספר המילים בתגובה. לדוגמה:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], max_tokens=10)
print(response.choices[0].message.content)

Output
1. Apple
2. Car

שינוי הערך ל-20:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], max_tokens=20)
print(response.choices[0].message.content)

Output
1. Apple
2. Car
3. Music
4. Ocean
5. Love

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

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], stream=True)
collected_messages = []
for chunk in response:
...   chunk_message = chunk.choices[0].delta.content
...   if chunk_message is not None:
...     collected_messages.append(chunk_message)
print(collected_messages)

Output
['', 'cat', '\n', 'book', '\n', 'computer', '\n', 'sun', '\n', 'water']

בקוד למעלה, המשתנה chunk_message מחזיק את תוכן ההודעה בכל חתיכה שמוחזרת על ידי ה- API. לפני שאנו מוסיפים כל חתיכה לרשימת collected_messages, אנו בודקים האם החתיכה היא None מאחר ותוכן החתיכה האחרונה בדרך כלל הוא None.

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

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

שלב 3 — יצירת פרומט מערכתי

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

תחילה, ניצור מודול Python המכיל פונקציה לטיפול במשימה זו. סגור את המפרש וצור קובץ חדש בשם story_generator.py בתיקיית הפרויקט שלך ב-Django.

(env)sammy@ubuntu:$ touch ~/my_blog_app/blog/blogsite/story_generator.py

לאחר מכן, תוכל להוסיף את מפתח ה- API של OpenAI למשתנים הסביבתיים שלך כך שלא תוסיף אותו ישירות לקובץ Python:

(env)sammy@ubuntu:$ export OPENAI_KEY="your-api-key"

פתח את story_generator.py ובתוכו, צור לקוח openai והגדר פונקציה בשם generate_story שמקבלת אוסף של מילים כקלט:

import os
from openai import OpenAI
client = OpenAI(api_key=os.environ["OPENAI_KEY"])
def generate_story(words):
    # קריאה ל- OpenAI API כדי ליצור את הסיפור
    response = get_short_story(words)
    # עיצוב והחזרת התגובה
    return format_response(response)

בפונקציה זו, אנו קוראים לפונקציה נפרדת, get_short_story, כדי לבצע את הקריאה ל- API של OpenAI עבור הסיפור ואז פונקציה נוספת, format_response, לעיצוב התגובה מה- API.

עכשיו, בואו נתמקד בפונקציה get_short_story. הוסיפו את השורות הבאות לתחתית קובץ ה- story_generator.py שלך:

def get_short_story(words):
    # בניית הפרומפט של המערכת
    system_prompt = f"""You are a short story generator.
    Write a short story using the following words: {words}.
    Do not go beyond one paragraph."""
    # ביצוע הקריאה ל- API
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{
            "role": "user",
            "content": system_prompt
        }],
        temperature=0.8,
        max_tokens=1000
    )

    # החזרת התגובה מה- API
    return response

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

לבסוף, נוכל ליישם את הפונקציה format_response. הוסיפו את השורות הבאות לתחתית קובץ ה- story_generator.py שלך:

def format_response(response):
    # חילוץ הסיפור שנוצר מהתגובה
    story = response.choices[0].message.content
    # הסרת טקסט או עיצוב לא רצויים
    story = story.strip()
    # החזרת הסיפור המעוצב
    return story

אתה יכול כעת לבדוק את הפונקציות הללו על ידי קריאה לפונקציה generate_story, ולהעביר אוסף של מילים כארגומנט שלה, ולהדפיס את התגובה שלה. הוסף את השורה הבאה לתחתית קובץ ה־story_generator.py:

print(generate_story("cat, book, computer, sun, water"))

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

(env) sammy@ubuntu:$ python ~/my_blog_app/blog/blogsite/story_generator.py

פלט:

In a cozy corner of a sunlit room, a fluffy cat named Whiskers lounged lazily next to a towering bookshelf. Amongst the rows of books, a curious computer hummed softly. As the sun streamed through the window, casting a warm glow, Whiskers noticed a small water stain on the shelf. Intrigued, the cat pawed at the book closest to the mark. As if guided by fate, the book opened to reveal a hidden compartment containing a glittering diamond necklace. With the secret now unveiled, Whiskers embarked on an unexpected adventure, where the sun, water, and the power of knowledge merged into a thrilling tale of mystery and discovery.

די מעניין! בוא נמחק את השורה עם הפקודת print מאחר ונקרא לפונקצית generate_story מתוך תצוגת Django. הסר את השורה המודגשת מתוך קובץ ה־story_generator.py:

print(generate_story("cat, book, computer, sun, water"))

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

המשך לשלב הבא לאינטגרציה של מודול ה־story_generator לתוך הפרוייקט שלך ב־Django.

שלב 4 – אינטגרציה עם תצוגת צד אחורי:

עליך ליצור תצוגה של Django ומסלול URL כדי לאינטגרציה של מודול ה־story_generator לתוך פרוייקט ה־Django שלך. בתצוגה תחלץ את המילים הצפויות מהבקשה, תקרא לפונקצית generate_story, ותחזיר את התגובה.

ראשית, פתח את הקובץ views.py בתיקיית היישום שלך ב־Django. יבא את המודולים הנדרשים והוסף פונקציית תצוגה בשם generate_story_from_words:

from django.http import JsonResponse
from .story_generator import generate_story

def generate_story_from_words(request):
    words = request.GET.get('words') # עיין במילים הצפויות מהבקשה
    story = generate_story(words) # קרא לפונקצית generate_story עם המילים שהוצאו
    return JsonResponse({'story': story}) # החזר את הסיפור כתגובת JSON

באם, פתח את הקובץ urls.py והוסף דפוס URL עבור צפייה ב־generate_story_from_words:

urlpatterns = [
    # דפוסי URL אחרים...
    path('generate-story/', views.generate_story_from_words, name='generate-story'),
]

כעת, ניתן לבקש את נקודת הקצה /generate-story/. לדוגמה, כדי לבדוק באמצעות curl, ניתן לבצע בקשת GET לנקודת הקצה עם המילים הצפויות כפרמטר שאילתה. פתח את הטרמינל שלך והרץ את הפקודה הבאה:

(env)sammy@ubuntu:$ curl "http://your_domain/generate-story/?words=cat,book,computer,sun,water"

ודא שהחלפת "http://your_domain" בדומיין האמיתי שבו מארח הפרויקט שלך ב־Django. המילים "cat,book,computer,sun,water" מייצגות את המילים הצפויות שבאמצעותן ברצונך ליצור סיפור. ניתן לשנות אותן לכל מילים שתרצה.

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

(env)sammy@ubuntu:$ curl "http://your_domain/generate-story/?words="cat,book,computer,sun,water"

פלט:

{"story": "Once upon a time, in a cozy little cottage nestled amidst a dense forest, a curious cat named Whiskers sat by the window, basking in the warm rays of the sun. As Whiskers lazily flicked his tail, his eyes caught sight of a dusty book lying on a nearby shelf. Intrigued, he carefully jumped onto the shelf, causing a cascade of books to tumble down, one opening up to reveal a hidden compartment. Inside, Whiskers discovered an ancient computer, its screen flickering to life as he brushed against the power button. Mesmerized by the glowing screen, Whiskers ventured into a world of virtual landscapes, where he roamed freely, chasing digital fish and pausing to admire breathtaking waterfalls. Lost in this newfound adventure, Whiskers discovered the wonders of both the tangible and virtual worlds, realizing that true exploration knows no bounds."}

מסקנה

לאחר השלמת המדריך הזה, למדת כיצד לאינטגרציה של דגמי OpenAI GPT לתוך פרויקט Django שלך באמצעות ממשק ה- API של OpenAI. ביצעת קריאות ל- API ChatCompletion, התאמת את ההתנהגות של הדגם על ידי עבודה עם פרמטרים כגון טמפרטורה ומקסימום רמות, ויצרת פרומט מערכת כדי לספק הקשר לדגם. כמו כן, אינטגרצת את מודול ה- story_generator לתוך פרויקט ה-Django שלך. כעת, תוכל ליצור סיפורים קצרים על ידי בקשה לנקודת הסיום /generate-story/ עם המילים הצפויות כפרמטר שאילתה.

כדי לשפר את הפרויקט שלך ב-Django עוד יותר, תוכל לחקור פונקציות נוספות של ממשק ה- API של OpenAI ולנסות עם פרומטי מערכת ופרמטרים שונים כדי ליצור סיפורים ייחודיים ויצירתיים.