OpenAI Development Series (6) : Le principe de fonctionnement et les exemples d'application du modèle Completions (développement de robots de dialogue multi-tours)

Le texte intégral compte plus de 7 000 mots au total et le temps de lecture prévu est d'environ 15 à 30 minutes | Plein de produits secs (avec code), il est recommandé de les collecter !

L'objectif de cet article est de comprendre la classe de modèle Completions fournie par OpenAI, de se familiariser avec ses méthodes d'appel et ses compétences d'ajustement des paramètres, et de fournir un moyen de développer des applications de niveau supérieur basées sur le modèle Completions en implémentant un robot de discussion à plusieurs tours. de dialogue.

Téléchargement du code cliquez ici

1. Le concept de base des complétions

Pour les modèles avancés d’apprentissage profond, ils sont généralement formés à partir d’une grande quantité de données textuelles, maîtrisant les relations grammaticales et plusieurs styles d’expression. Au cours de la formation sur ce vaste espace sémantique, les modèles apprennent non seulement des modèles textuels de base, mais sont également affinés pour mieux correspondre à l'intention humaine spécifique. Lorsqu'un modèle effectue une prédiction, son essence est de produire une sortie textuelle correspondante basée sur une entrée (ou une invite) donnée . Typiquement, la formation d'un tel modèle se divise en deux phases principales :

• Phase 1 : Pré-formation

À ce stade, le modèle est entraîné à l’aide de grandes quantités de textes non étiquetés, tels que des livres et des articles collectés en ligne. Cette étape concerne principalement la formation du modèle linguistique, afin que le modèle puisse prédire le mot suivant dans un contexte donné, afin de maîtriser le vocabulaire, la grammaire et les connaissances de base .

• Phase deux : mise au point

Une fois la pré-formation terminée, le modèle sera entraîné davantage sur des données spécifiques à la tâche. Par exemple, pour une tâche de réponse à des questions, des paires de questions et de réponses peuvent être fournies pour affiner le modèle afin d'obtenir de meilleures performances sur la tâche.

Les modèles de la série GPT d'OpenAI sont leaders dans le domaine de la PNL. Il fournit une interface API pour les développeurs, permettant aux développeurs d'envoyer des invites textuelles au modèle et d'obtenir la réponse du modèle, ce qui signifie que les développeurs peuvent utiliser directement les services d'OpenAI sans formation ni déploiement de grands modèles par eux-mêmes .

Le modèle dit « Complétions » fait en fait référence à la capacité de complétion automatique de texte fournie par OpenAI sur la base de sa série de modèles GPT . Ce type de modèle peut non seulement générer et compléter automatiquement du texte, mais également répondre à des questions, rédiger des articles, etc. Ce processus, le mécanisme par lequel le texte correspondant est généré en fonction de l'invite, est appelé « Achèvement ». Par conséquent, un modèle capable de remplir cette fonction est appelé « Modèle d'achèvement » . Par exemple, text-davinci-003 basé sur le modèle text-davinci-002 après réglage fin du RLHF est un tel modèle d'achèvement.

En général : Les complétions sont une API fournie par OpenAI pour générer du texte. L'API des complétions est principalement utilisée pour répondre aux questions. L'utilisateur saisit un texte d'invite et le modèle donne la sortie correspondante en fonction de l'invite de texte .

2. Classe de modèle d'achèvement

À l'heure actuelle, les classes de modèles de complétion publiées sur le site officiel d'OpenAI sont les suivantes :

Les quatre types de modèles A, B, C et D avec le logo « texte » publiés par OpenAI appartiennent à la série de modèles Completions, c'est-à-dire les modèles de la série GPT-3. GPT-3.5 et GPT-4 sont définis comme le modèle de complétion de chat .

D'un point de vue fonctionnel, le modèle Completions a des fonctions plus basiques et complètes, et c'est le seul modèle pour lequel OpenAI fournit une interface de réglage fin. En revanche, le modèle Chat Completions est un modèle plus spécialisé et avancé. Chaque modèle a ses scénarios d'application uniques. Cet article explique d'abord principalement les paramètres et l'utilisation du modèle de complétion.

Par exemple, API Completion.create

3.1 Explication détaillée des paramètres

Dans le grand modèle en ligne fourni par OpenAI, tous les modèles de complétion doivent être invoqués via Completion.create, et le modèle d'invocation correspondant et les paramètres liés au modèle sont définis via des hyperparamètres pendant le processus d'invocation réel.

Regardez la liste des paramètres donnée par le site officiel d'OpenAI :

Les paramètres sont expliqués comme suit :

3.2 Test d'appel

• Étape 1 : introduisez les packages de dépendances et chargez OPENAI_API_KEY

import os
import openai

openai.api_key = os.getenv("OPENAI_API_KEY")

• Étape 2 : Appeler le test

Tous les modèles de complétion doivent être appelés via la fonction Completion.create(). Dans le processus d'appel réel, le modèle d'appel correspondant et les paramètres liés au modèle sont définis via les hyperparamètres. Le code de test est le suivant :

response = openai.Completion.create(
           model="text-davinci-003",
           prompt="This is a test message"
           )

Le résultat est le suivant :

Si le programme ne signale pas d'erreur, cela prouve essentiellement qu'il a été appelé normalement. La réponse renvoyée contient l'identifiant text_completion (code de tâche d'achèvement), le résultat de la réponse du modèle et l'utilisation des ressources de ce cycle d'appel. À partir de la réponse du modèle, les achèvements sont utilisé comme complétion Le modèle continuera à générer le contenu suivant en fonction de l'entrée ,C'est - à - dire from Ceci est un message de test -> Ceci est un message de test pour tester le fonctionnement des e-mails.

L'appel le plus simple consiste à définir uniquement les paramètres model et prompt , et seuls ces deux paramètres sont requis, où model indique le modèle à appeler et prompt indique le mot d'invite.

• Étape 3 : manipulation des données

Après avoir obtenu la réponse, vous pouvez utiliser Python pour effectuer certaines opérations de base. Tout d'abord, la réponse est un objet de type OpenAIObject.

• Extraire le texte spécifique renvoyé en réponse

• Extraire l'objet texte

Il convient de souligner que les résultats des grands modèles génératifs sont souvent incertains et difficiles à reproduire . Bien qu'en théorie, lorsqu'il temperatureest défini sur 0, le modèle choisira toujours le jeton suivant avec la probabilité la plus élevée à chaque étape, rendant le résultat plus sûr et cohérent. Mais en fait, en raison de la limitation de précision du calcul interne du modèle, des erreurs d'arrondi et d'autres facteurs, la cohérence totale des résultats de sortie ne peut être garantie.

En plus de la température, OpenAI ne fournit actuellement aucun paramètre supplémentaire pouvant être utilisé pour contrôler le caractère aléatoire des résultats. Bien que top_p puisse affecter la sortie, il ne contrôle pas entièrement le caractère aléatoire du modèle. De plus, le grand modèle en ligne OpenAI actuel ne dispose pas de paramètres similaires aux valeurs de départ de nombres aléatoires dans le domaine de l'apprentissage automatique. Par conséquent, dans l’état actuel des choses, il est presque impossible de contrôler la sortie des grandes langues afin qu’elles puissent être reproduites.

3.3 Pratique de réglage des paramètres

Le grand modèle de langage est un modèle de boîte noire très complexe, qui aboutit souvent à des réglages de paramètres qui ne peuvent pas être déduits complètement conformément à la situation théorique. Par conséquent, beaucoup de pratique est nécessaire pour accumuler de l'expérience dans l'utilisation de différents paramètres, qui c'est-à-dire maîtriser l'achèvement réel des différents paramètres.L'effet du processus sur le résultat de sortie.

Essayons-le d'abord et essayons d'ajuster les paramètres de base de Completion.create pour observer les changements dans la sortie du modèle

3.3.1 Paramètre n

response = openai.Completion.create(
           model="text-davinci-003",
           prompt="请问什么是机器学习",
           max_tokens=1000,
           n=3
           )

• Paramètre n : indique qu'une invite renvoie plusieurs complétions

Lorsque n=3 est saisi, 3 complétions seront renvoyées, comme suit :

Vous pouvez en visualiser un seul comme ceci :

response["choices"][0]["text"].strip('？\n\n')

Le résultat est le suivant :

Lorsque n n'est pas égal à 1, la méthode index est utilisée pour récupérer le résultat .Lorsque n=3 est entré,response["choices"][0] doit récupérer le contenu du premier Completion,etresponse["choices" ][1 ] est de reprendre le contenu du deuxième Achèvement...

Encapsulez le processus ci-dessus dans une fonction, le code est le suivant :

import openai
import json

def get_completion_response(model, prompt, n=1):
    """
    使用OpenAI的API查询并获取响应。

    参数:
    - model (str): 要查询的模型名称，例如 "text-davinci-003"。
    - prompt (str): 用于查询的提示或问题。
    - n (int): 返回响应的数量，默认为1。

    返回:
    - str: 一个包含所有响应的JSON字符串。

    示例：
    result = get_completion_response("text-davinci-003", "请问什么是机器学习", 3)
    print(result)
    """

    # 使用OpenAI的API获得响应
    response = openai.Completion.create(
        model=model,
        prompt=prompt,
        max_tokens=1000,
        n=n
    )

    # 存储处理后的响应文本
    response_texts = []

    # 根据n的大小，依次处理每一个响应的内容
    for i in range(n):
        text = response["choices"][i]["text"].strip('？\n\n')
        print(f"Response {
      
      i + 1}: {
      
      text}")  # 打印内容
        response_texts.append(text)

    # 把返回内容封装在一个Json中
    response_json = json.dumps({
    
    "responses": response_texts}, ensure_ascii=False)
    return response_json

Testez la fonction :

# 调用函数示例
model = "text-davinci-003"
prompt = "请问什么是机器学习"
n = 3

# result = get_completion_response(model=model, prompt=prompt, n=n)
# print(result)
get_completion_response(model=model, prompt=prompt, n=n)

Regardez le résultat :

3.3.2 paramètre température

• la température est un paramètre très central et important, qui est utilisé pour contrôler le caractère aléatoire des résultats de sortie du modèle. Sa plage de valeurs est comprise entre 0 et 2 et la valeur par défaut est 1. Plus la valeur est grande, plus le caractère aléatoire du modèle est grand .

Essayez d'abord de régler la température = 1,5, le code d'appel est le suivant :

response = openai.Completion.create(
           model="text-davinci-003",
           prompt="请问什么是机器学习",
           max_tokens=1000,
           n=3,
           temperature=1.5
           )

Regardez les résultats renvoyés par le modèle :

En fait, il est évident que cette réponse est déjà très aléatoire et qu'elle ne peut même pas être reliée à une phrase normale.

Essayez de définir une valeur de température plus petite et observez le résultat :

response = openai.Completion.create(
           model="text-davinci-003",
           prompt="请问什么是机器学习",
           max_tokens=1000,
           n=3,
           temperature=0.8
           )

Regardez les résultats :

Il ressort des résultats que lorsque la valeur du paramètre température diminue, la réponse sera plus rigoureuse. Cela montre que la température a une grande influence sur le caractère aléatoire des résultats de sortie de texte, ce paramètre doit donc être pris au sérieux.

Les compétences de réglage des deux paramètres de température peuvent être utilisées à titre de référence, mais la manière de les régler spécifiquement doit être jugée en fonction de la situation réelle.

• La valeur de la température a une grande influence sur les résultats du modèle, et souvent un petit ajustement de la valeur entraînera un impact très important, la plage d'ajustement recommandée est donc comprise entre **[0,8,1,2]** ;
• Au fur et à mesure que la valeur de la température augmente, le texte renvoyé passera progressivement d'une expression rigoureuse à un « non-sens ». Cependant, lorsque la température atteint certaines valeurs, les résultats renvoyés montreront certaines caractéristiques « inspirantes », laissant parfois le modèle répondre avec plus un contenu divergent peut nous donner une certaine inspiration.

Lorsque le paramètre température est ajouté, la fonction est mise à jour comme suit :

import openai
import json

def get_completion_response(model, prompt, n=1, temperature=0.8):
    """
    使用OpenAI的API查询并获取响应。
    
    参数:
    - model (str): 要查询的模型名称，例如 "text-davinci-003"。
    - prompt (str): 用于查询的提示或问题。
    - n (int): 返回响应的数量，默认为1。
    - temperature (float): 用于控制输出随机性的参数，值范围为[0, 1]。较低的值会使输出更确定，而较高的值会使其更随机。
    
    返回:
    - str: 一个包含所有响应的JSON字符串。
    
    示例:
    result = get_completion_response("text-davinci-003", "请问什么是机器学习", 3, 0.8)
    print(result)
    """

    # 使用OpenAI的API获得响应
    response = openai.Completion.create(
               model=model,
               prompt=prompt,
               max_tokens=1000,
               n=n,
               temperature=temperature
               )
    
    # 存储处理后的响应文本
    response_texts = []

    # 根据n的大小，依次处理每一个响应的内容
    for i in range(n):
        text = response["choices"][i]["text"].strip('？\n\n')
        print(f"Response {
      
      i+1}: {
      
      text}")  # 打印内容
        response_texts.append(text)

    # 把返回内容封装在一个Json中
    response_json = json.dumps({
    
    "responses": response_texts}, ensure_ascii=False)
    return response_json

faire un test :

# 调用函数示例
model = "text-davinci-003"
prompt = "请问什么是机器学习"
n = 3
temperature = 0.8 

# result = get_completion_response(model=model, prompt=prompt, n=n)
# print(result)
get_completion_response(model=model, prompt=prompt, n=n, temperature=temperature)

Regardez la sortie du modèle :

3.3.3 Paramètre présence_penalty

• Le paramètre présence_penalty contrôle le raffinement de l'instruction renvoyée

Compréhension simple : plus la température est élevée, plus il y a de bêtises, plus lapresence_penalty est petite, plus verbose , le paramètre présence_penalty prend une valeur en [-2,2], plus la valeur est grande, plus le résultat renvoyé est raffiné, plus la valeur est petite. valeur, plus le résultat renvoyé est détaillé.

Utilisez toujours "qu'est-ce que l'apprentissage automatique" comme invite, observez les résultats de sortie lorsque la valeur de présence_penalty est différente, lorsqu'une valeur plus grande est prise,

response = openai.Completion.create(
           model="text-davinci-003",
           prompt="请问什么是机器学习",
           max_tokens=1000,
           n=3,
           presence_penalty=2
           )

Regardez les résultats renvoyés par le modèle :

Le résultat à ce stade est très raffiné. Et si vous définissez presence_penalty sur -2 :

response = openai.Completion.create(
           model="text-davinci-003",
           prompt="请问什么是机器学习",
           max_tokens=1000,
           n=3,
           presence_penalty=-2
           )

Regardez les résultats renvoyés par le modèle :

C'est effectivement un peu fastidieux, le texte est court et ce n'est pas si évident. Quand la sortie est longue, c'est très intuitif.

Après des tests à long terme et un examen de l'expérience d'autres développeurs, je suggère personnellement que le paramètre présence_penalty et le paramètre température soient utilisés en combinaison lors de l'appel réel du grand modèle pour l'achèvement, ce qui permet souvent d'obtenir de très bons résultats . De manière générale, si vous souhaitez que le modèle soit plus créatif, vous augmenterez la valeur de la température et réduisez de manière appropriée la valeur de la présence_penalty, par exemple, vous pouvez faire ceci :

response = openai.Completion.create(
           model="text-davinci-003",
           prompt="请问什么是机器学习",
           max_tokens=1000,
           n=3,
           presence_penalty=-0.8,
           temperature=1.2
           )

Le résultat est le suivant :

À l’inverse, si vous souhaitez que le résultat soit plus précis, essayez de baisser la température de manière appropriée et d’augmenter la valeur de presence_penalty :

response = openai.Completion.create(
           model="text-davinci-003",
           prompt="请问什么是机器学习",
           max_tokens=1000,
           n=3,
           presence_penalty=2,
           temperature=0.8
           )

Le résultat est le suivant :

**Cela signifie que l'on constate souvent que certains grands modèles de langage ont trois modes différents, qui sont le mode précision, le mode équilibre et le mode créativité. Les deux paramètres les plus fondamentaux pour la mise en œuvre de ces différents modes sont le paramètre présence_penalty et le paramètre température. . ** Alors vous savez maintenant, comment sont nés les trois modes de New Bing ?

Mettez à nouveau à jour la fonction et ajoutez le paramètre présence_penalty, le code est le suivant :

import openai
import json

def get_completion_response(model, prompt, n=1, temperature=0.8, presence_penalty=2.0):
    """
    使用OpenAI的API查询并获取响应。
    
    参数:
    - model (str): 要查询的模型名称，例如 "text-davinci-003"。
    - prompt (str): 用于查询的提示或问题。
    - n (int): 返回响应的数量，默认为1。
    - temperature (float): 用于控制输出随机性的参数，值范围为[0, 1]。较低的值会使输出更确定，而较高的值会使其更随机。
    - presence_penalty (float): 用于增加或减少新内容出现在输出中的惩罚。
    
    返回:
    - str: 一个包含所有响应的JSON字符串。
    
    示例:
    result = get_completion_response("text-davinci-003", "请问什么是机器学习", 3, 0.8, 2)
    print(result)
    """

    # 使用OpenAI的API获得响应
    response = openai.Completion.create(
               model=model,
               prompt=prompt,
               max_tokens=1000,
               n=n,
               temperature=temperature,
               presence_penalty=presence_penalty
               )
    
    # 存储处理后的响应文本
    response_texts = []

    # 根据n的大小，依次处理每一个响应的内容
    for i in range(n):
        text = response["choices"][i]["text"].strip('？\n\n')
        print(f"Response {
      
      i+1}: {
      
      text}")  # 打印内容
        response_texts.append(text)

    # 把返回内容封装在一个Json中
    response_json = json.dumps({
    
    "responses": response_texts}, ensure_ascii=False)
    return response_json

Testez la fonctionnalité de la fonction :

# 调用函数示例
model = "text-davinci-003"
prompt = "请问什么是机器学习"
n = 3
temperature = 0.8 
presence_penalty = 2.0

# result = get_completion_response(model=model, prompt=prompt, n=n)
# print(result)
get_completion_response(model=model, prompt=prompt, n=n, temperature=temperature, presence_penalty=presence_penalty)

Regardez la sortie du modèle :

3.3 4 paramètres best_of

• Paramètre best_of : laissez le modèle prédire plusieurs ensembles de résultats et sélectionnez le meilleur pour la sortie .

Par exemple : si vous définissez best_of=5, cela signifie créer un total de 5 textes alternatifs, puis sélectionner un groupe avec la probabilité la plus élevée (score le plus élevé) pour la sortie :

response = openai.Completion.create(
           model="text-davinci-003",
           prompt="请问什么是机器学习",
           max_tokens=1000,
           presence_penalty=-1,
           temperature=1.2,
           best_of=5
           )

Le résultat du modèle est le suivant :

L'effet évident de ce paramètre est qu'à mesure que la valeur de best_of augmente, la qualité des résultats finaux augmente également.Après tout, plusieurs réponses sont le meilleur choix, mais en même temps, elles consomment beaucoup de quotas de jetons. et des quotas pour le nombre d'appels par minute, en fonction de la situation.

Il existe une combinaison de paramètres : utilisez best_of et n en même temps, comme best_of=2, n=2, quatre requêtes seront envoyées et deux résultats seront renvoyés à la fin.

best_of consiste à filtrer automatiquement les meilleurs résultats, et le paramètre n peut prendre en charge la sélection manuelle des meilleurs résultats

Mettez donc à jour davantage la fonction encapsulée :

import openai
import json

def get_completion_response(model, prompt, n=1, temperature=0.8, presence_penalty=2.0, best_of=1):
    """
    使用OpenAI的API查询并获取响应。
    
    参数:
    - model (str): 要查询的模型名称，例如 "text-davinci-003"。
    - prompt (str): 用于查询的提示或问题。
    - n (int): 返回响应的数量，默认为1。
    - temperature (float): 用于控制输出随机性的参数，值范围为[0, 1]。较低的值会使输出更确定，而较高的值会使其更随机。
    - presence_penalty (float): 用于增加或减少新内容出现在输出中的惩罚。
    - best_of (int): 用于指定多少次尝试中选择最佳输出。
    
    返回:
    - str: 一个包含所有响应的JSON字符串。
    
    示例:
    result = get_completion_response("text-davinci-003", "请问什么是机器学习", 3, 0.8, 2, 5)
    print(result)
    """

    # 使用OpenAI的API获得响应
    response = openai.Completion.create(
               model=model,
               prompt=prompt,
               max_tokens=1000,
               n=n,
               temperature=temperature,
               presence_penalty=presence_penalty,
               best_of=best_of
               )
    
    # 存储处理后的响应文本
    response_texts = []

    # 根据n的大小，依次处理每一个响应的内容
    for i in range(n):
        text = response["choices"][i]["text"].strip('？\n\n')
        print(f"Response {
      
      i+1}: {
      
      text}")  # 打印内容
        response_texts.append(text)

    # 把返回内容封装在一个Json中
    response_json = json.dumps({
    
    "responses": response_texts}, ensure_ascii=False)
    return response_json

Testez-le enfin :

# 调用函数示例
model = "text-davinci-003"
prompt = "请问什么是机器学习"
n = 3
temperature = 0.8 
presence_penalty = 2.0
best_of = 3

# result = get_completion_response(model=model, prompt=prompt, n=n)
# print(result)
get_completion_response(model=model, prompt=prompt, n=n, temperature=temperature, presence_penalty=presence_penalty, best_of=best_of)

Regardez le résultat du modèle :

ok, pas de problème, vous pouvez essayer plus de paramètres par vous-même pour enrichir cette fonction pour une utilisation future.

4. Utiliser le modèle d'achèvement pour réaliser des robots de dialogue à plusieurs tours

Après une compréhension et une maîtrise approfondies de l'API du modèle de complétion à travers le contenu ci-dessus, vous avez en fait déjà Completion.create()la possibilité d'utiliser des fonctions pour développer des applications avancées . Cet article montre comment développer un exemple de chatbot avec plusieurs tours de dialogue et s'adapter à différents scénarios d'utilisation en ajustant différents paramètres. Ceci est juste une idée d'application possible pour votre référence et votre inspiration.

Tout d’abord, le processus métier d’un chatbot devrait être le suivant :

Afin de réaliser ce processus, le projet peut être démonté étape par étape.

• Étape 1 : Créer la fonction de chat

Pour créer un chatbot, l’essentiel est de disposer openai.Completion.create()des fonctionnalités de base auxquelles envoyer des demandes et obtenir des réponses . Après avoir implémenté les fonctions de base, certaines optimisations sont ajoutées, comme suit

1. Paramétrage :

Actuellement, model, temperature, et presence_penaltysont des variables externes. Pour rendre les fonctions plus générales et autonomes, il est recommandé de les définir comme paramètres de la fonction.

2. Gestion des erreurs :

Pour mieux comprendre ce qui n'a pas fonctionné, envisagez de renvoyer un message d'erreur plus spécifique. Par exemple : return f"Error: {str(exc)}".

3. Traitement des résultats :

Les retours directs answerpeuvent contenir des espaces supplémentaires, des nouvelles lignes, etc. Assurez-vous que le texte renvoyé est proprement formaté, le cas échéant.

4. Ajouter un journal :

À l'intérieur de la fonction, ajoutez des journaux pour enregistrer les étapes critiques ou les erreurs détectées, ce qui sera plus pratique pendant le développement et le débogage. La fonction de dialogue finale est donc la suivante :

def chat(prompt, model="text-davinci-003", temperature=1.0, presence_penalty=0.0):
    """
    Send a chat prompt to the OpenAI API and get the answer.
    
    :param prompt: The chat prompt.
    :param model: The model to be used.
    :param temperature: Sampling temperature.
    :param presence_penalty: Presence penalty value.
    
    :return: The AI's response or error message.
    """
    try:
        response = openai.Completion.create(
            model=model,
            prompt=prompt,
            max_tokens=1000,
            temperature=temperature, 
            presence_penalty=presence_penalty,
            stop=[" Human:", " AI:"]
        )
        answer = response["choices"][0]["text"].strip()
        return answer
    except Exception as exc:
        error_message = f"Error: {
      
      str(exc)}"
        print(error_message)  # This is a simple logging, consider using a logging library in real applications.
        return error_message

• Étape 2 : Définir trois modes de dialogue

Comme mentionné dans l'article ci-dessus, le principe du modèle de dialogue similaire à New bing est réalisé en préréglant différentes combinaisons de paramètres de température et de paramètres de présence_penalty , qui peuvent être réalisées de cette manière :

# 三种模式对应的参数,依次为平衡模式、精确模式、创造力模式
if mode == 'balance':
    temperature = 1
    presence_penalty = 0
elif mode == 'precision':
    temperature = 0.8
    presence_penalty = 2
elif mode == 'creativity':
    temperature = 1.2
    presence_penalty = -1  
else:
    raise ValueError("Invalid mode. Choose from 'balance', 'precision', or 'creativity'.")  

Compréhension simple : plus la température est élevée, plus il y a d'absurdités, plus la pénalité de présence est faible, plus elle est verbeuse

• Étape 3 : Construire une logique de dialogue à plusieurs tours

Pour réaliser plusieurs cycles de dialogue, l'essentiel est de faire en sorte que le grand modèle de ce cycle de dialogue ait la capacité de mémoire contextuelle. L'idée est de relier les questions proposées par les humains lors de ce cycle et les questions soulevées par les humains lors des tours précédents. + les questions d'IA correspondantes, et saisissez-les ensemble. Dans le grand modèle , le processus d'implémentation du code est le suivant :

# 存储对话记录
chat_history = []

# 执行多轮对话
while True:
    # 启动对话框
    user_input = input("Human: ")

    # 输入"退出"结束对话
    if user_input == "退出":
        break

    # 将之前的对话和当前的用户输入组合为新的提示
    chat_prompt = "\n".join(chat_history + ["Human: " + user_input])

    # 使用chat函数获取回答
    ai_response = chat(chat_prompt, temperature, presence_penalty)

    # 如果回答是错误消息，则尝试再次调用chat函数
    while ai_response.startswith("Error:"):
        print("请求失败，正在重试...")
        ai_response = chat(chat_prompt, temperature, presence_penalty)

    # 输出机器人的回答
    print(f"AI: {
      
      ai_response}")

    # 更新聊天记录
    chat_history.extend(["Human: " + user_input, "AI: " + ai_response])

    # 保留最多10轮对话
    if len(chat_history) > 20:  # 因为每轮对话有2条记录：一条Human，一条AI
        chat_history = chat_history[2:]

Vous pouvez ajouter une instruction d'impression à la position spécifiée pour afficher la sortie d'invite de chaque tour, comme suit :

# ... [前面的代码不变]

# 将之前的对话和当前的用户输入组合为新的提示
chat_prompt = "\n".join(chat_history + ["Human: " + user_input])

# 打印chat_prompt以查看每轮的模型输入
print("\n当前的chat_prompt:\n", chat_prompt, "\n")

# ... [前面的代码不变]
# 更新聊天记录
chat_history.extend(["Human: " + user_input, "AI: " + ai_response])

# 打印chat_history以查看当前的对话历史
print("\n当前的chat_history:\n", chat_history, "\n")

faire un test :

De cette façon, le modèle a une capacité de mémoire contextuelle, mais il convient de noter que chaque cycle de dialogue a 2 enregistrements : un humain, un IA, donc lorsque vous souhaitez conserver 10 informations de conversation récentes, la limite de longueur de chat_history doit être écrite. comme >20.

• Étape 4 : Terminer la fonction

def multi_round_chat(model='text-davinci-003', mode='balance'):
    """
    基于Completion.create函数的多轮对话机器人
    
    :param model: The model to be used.
    :param mode: The chat mode, which can be 'balance', 'precision', or 'creativity'.
    """
    
    def chat(prompt, temperature=1.0, presence_penalty=0.0):
        """
        对话函数
        Send a chat prompt to the OpenAI API and get the answer.

        :param prompt: The chat prompt.
        :param temperature: Sampling temperature.
        :param presence_penalty: Presence penalty value.

        :return: The AI's response or error message.
        """
        try:
            response = openai.Completion.create(
                model=model,
                prompt=prompt,
                max_tokens=1000,
                temperature=temperature, 
                presence_penalty=presence_penalty,
                stop=[" Human:", " AI:"]
            )
            answer = response["choices"][0]["text"].strip()
            return answer
        except Exception as exc:
            error_message = f"Error: {
      
      str(exc)}"
            print(error_message)  # This is simple logging. In real applications, consider using a logging library.
            return error_message
    
    # 设置三种对话模式的参数
    if mode == 'balance':
        temperature = 1
        presence_penalty = 0
    elif mode == 'precision':
        temperature = 0.8
        presence_penalty = 2
    elif mode == 'creativity':
        temperature = 1.2
        presence_penalty = -1  
    else:
        raise ValueError("Invalid mode. Choose from 'balance', 'precision', or 'creativity'.")
    
    # 启动对话框
    print("请输入你的问题 (输入'退出'结束对话)：")

    # 存储对话记录
    chat_history = []

    # 执行多轮对话
    while True:
        # 启动对话框
        user_input = input("Human: ")

        # 输入"退出"结束对话
        if user_input == "退出":
            break

        # 将之前的对话和当前的用户输入组合为新的提示
        chat_prompt = "\n".join(chat_history + ["Human: " + user_input])
        
        # 打印chat_prompt以查看每轮的模型输入
        print("\n当前的chat_prompt:\n", chat_prompt, "\n")

        # 使用chat函数获取回答
        ai_response = chat(chat_prompt, temperature, presence_penalty)

        # 如果回答是错误消息，则尝试再次调用chat函数
        while ai_response.startswith("Error:"):
            print("请求失败，正在重试...")
            ai_response = chat(chat_prompt, temperature, presence_penalty)

        # 输出机器人的回答
        print(f"AI: {
      
      ai_response}")

        # 更新聊天记录
        chat_history.extend(["Human: " + user_input, "AI: " + ai_response])
        
        # 打印chat_history以查看当前的对话历史
        print("\n当前的chat_history:\n", chat_history, "\n")

        # 保留最多10轮对话
        if len(chat_history) > 20:  # 因为每轮对话有2条记录：一条Human，一条AI
            chat_history = chat_history[2:]

    print("下次再见！")

Testez-le enfin :

Deux détails :

• L'entrée 1 est : "Bonjour, savez-vous ce qu'est l'apprentissage automatique ?" Il y aura un point d'interrogation (?) à la fin. C'est parce que text-davinci-003 est actuellement utilisé, qui est un modèle de complétion !
• l'entrée 2 a directement saisi "comment dois-je apprendre les points spécifiques ?", car un point d'interrogation (?) a été ajouté, c'était une entrée complète, donc elle n'a pas été complétée, ce qui a vérifié le problème en détail 1, et en même temps , n'a pas mentionné le contenu lié à l'apprentissage automatique, mais la réponse du modèle est liée à "comment apprendre l'apprentissage automatique", qui vérifie également que le modèle a la capacité de mémoire contextuelle .

V. Résumé

Cet article développe les concepts de base et les classes de modèles des modèles Completions et Chat Completions d'OpenAI. Ensuite, une analyse approfondie de l'API Completion.create est effectuée, y compris une explication détaillée des paramètres, des tests de code et des pratiques de réglage des paramètres, en particulier l'explication détaillée de paramètres tels que n, température, présence_penalty et best_of. Enfin, sur la base de la fonction Completion.create, un robot de dialogue multi-tours est réalisé, montrant la flexibilité du système de dialogue IA. La maîtrise de ces connaissances revêt une importance directrice importante pour l’optimisation des systèmes de dialogue d’IA.

Enfin, merci d’avoir lu cet article ! Si vous sentez que vous avez gagné quelque chose, n'oubliez pas d'aimer, de mettre en signet et de me suivre, c'est la motivation de ma création continue. Si vous avez des questions ou des suggestions, vous pouvez laisser un message dans la zone de commentaires, je ferai de mon mieux pour répondre et accepter vos commentaires. S'il y a un sujet particulier que vous aimeriez connaître, n'hésitez pas à me le faire savoir et je serai ravi d'écrire un article à ce sujet. Merci pour votre soutien et au plaisir de grandir avec vous !