ChatGptNet
ChatGptNet 3.3.9
Eine ChatGPT -Integrationsbibliothek für .NET, die sowohl OpenAI- als auch Azure OpenAI -Service unterstützt.
Die Bibliothek ist auf Nuget erhältlich. Suchen Sie einfach nach Chatgptnet in der Paket -Manager -GUI oder führen Sie den folgenden Befehl in der CLI .NET aus:
dotnet add package ChatGptNetRegistrieren Sie den ChatGPT -Dienst beim Anwendungsstart:
builder . Services . AddChatGpt ( options =>
{
// OpenAI.
//options.UseOpenAI(apiKey: "", organization: "");
// Azure OpenAI Service.
//options.UseAzure(resourceName: "", apiKey: "", authenticationType: AzureAuthenticationType.ApiKey);
options . DefaultModel = " my-model " ;
options . DefaultEmbeddingModel = " text-embedding-ada-002 " ;
options . MessageLimit = 16 ; // Default: 10
options . MessageExpiration = TimeSpan . FromMinutes ( 5 ) ; // Default: 1 hour
options . DefaultParameters = new ChatGptParameters
{
MaxTokens = 800 ,
//MaxCompletionTokens = 800, // o1 series models support this property instead of MaxTokens
Temperature = 0.7
} ;
} ) ;Chatgptnet unterstützt sowohl den OpenAI- als auch den Azure OpenAI -Service. Daher müssen die richtigen Konfigurationseinstellungen basierend auf dem ausgewählten Anbieter festgelegt werden:
ChatGPT kann mit verschiedenen Modellen für die CHAT -Fertigstellung verwendet werden, sowohl im OpenAI- als auch im Azure OpenAI -Service. Mit der DefaultModel -Eigenschaft können Sie das verwendete Standardmodell angeben, es sei denn, Sie übergeben einen expliziten Wert in den AskaSync- oder Asystreamasync -Methoden.
Auch wenn es für Chat -Gespräche nicht streng notwendig ist, unterstützt die Bibliothek auch die Einbettungs -API sowohl auf OpenAI als auch auf Azure Openai. Bei der Fertigstellung der Chat können Einbettungen mit verschiedenen Modellen durchgeführt werden. Mit der Eigenschaft DefaultEmbeddingModel können Sie das verwendete Standardmodell angeben, es sei denn, Sie übergeben einen expliziten Wert in der Getembedingasync -Methode.
Derzeit verfügbare Modelle sind:
Sie haben feste Namen, die in der Datei openaichatgptmodels.cs erhältlich sind.
Im Azure OpenAI -Service müssen Sie zuerst ein Modell bereitstellen, bevor Sie Anrufe tätigen können. Wenn Sie ein Modell bereitstellen, müssen Sie ihm einen Namen zuweisen, der dem Namen mit Chatgptnet übereinstimmen muss.
Beachten Sie, dass einige Modelle nicht in allen Regionen verfügbar sind. Sie können auf die Seite "Zusammenfassung der Region Verfügbarkeit" beziehen, um die aktuellen Verfügbarkeiten zu überprüfen.
Chatgpt soll Konverszenarien unterstützen: Der Benutzer kann mit ChatGPT sprechen, ohne den vollständigen Kontext für jede Interaktion anzugeben. Die Gesprächsgeschichte wird jedoch nicht vom OpenAI- oder Azure OpenAI -Service verwaltet, daher liegt es an uns, den aktuellen Staat zu behalten. Standardmäßig behandelt ChatgptNet diese Anforderung mit einem Speichercache, der Nachrichten für jede Konversation speichert. Das Verhalten kann unter Verwendung der folgenden Eigenschaften festgelegt werden:
Bei Bedarf ist es möglich, einen benutzerdefinierten Cache zu liefern, indem die iChatgptCache -Schnittstelle implementiert und dann die WithCache -Erweiterungsmethode aufgerufen wird:
public class LocalMessageCache : IChatGptCache
{
private readonly Dictionary < Guid , IEnumerable < ChatGptMessage > > localCache = new ( ) ;
public Task SetAsync ( Guid conversationId , IEnumerable < ChatGptMessage > messages , TimeSpan expiration , CancellationToken cancellationToken = default )
{
localCache [ conversationId ] = messages . ToList ( ) ;
return Task . CompletedTask ;
}
public Task < IEnumerable < ChatGptMessage > ? > GetAsync ( Guid conversationId , CancellationToken cancellationToken = default )
{
localCache . TryGetValue ( conversationId , out var messages ) ;
return Task . FromResult ( messages ) ;
}
public Task RemoveAsync ( Guid conversationId , CancellationToken cancellationToken = default )
{
localCache . Remove ( conversationId ) ;
return Task . CompletedTask ;
}
public Task < bool > ExistsAsync ( Guid conversationId , CancellationToken cancellationToken = default )
{
var exists = localCache . ContainsKey ( conversationId ) ;
return Task . FromResult ( exists ) ;
}
}
// Registers the custom cache at application startup.
builder . Services . AddChatGpt ( /* ... */ ) . WithCache < LocalMessageCache > ( ) ;Wir können auch ChatGPT -Parameter für die Chat -Fertigstellung beim Start festlegen. Überprüfen Sie die offizielle Dokumentation für die Liste der verfügbaren Parameter und deren Bedeutung.
Die Konfiguration kann automatisch aus der Symbolfiguration unter Verwendung eines ChatGPT -Abschnitts in der Datei appSettings.json gelesen werden:
"ChatGPT": {
"Provider": "OpenAI", // Optional. Allowed values: OpenAI (default) or Azure
"ApiKey": "", // Required
//"Organization": "", // Optional, used only by OpenAI
"ResourceName": "", // Required when using Azure OpenAI Service
"ApiVersion": "2024-10-21", // Optional, used only by Azure OpenAI Service (default: 2024-10-21)
"AuthenticationType": "ApiKey", // Optional, used only by Azure OpenAI Service. Allowed values: ApiKey (default) or ActiveDirectory
"DefaultModel": "my-model",
"DefaultEmbeddingModel": "text-embedding-ada-002", // Optional, set it if you want to use embedding
"MessageLimit": 20,
"MessageExpiration": "00:30:00",
"ThrowExceptionOnError": true // Optional, default: true
//"User": "UserName",
//"DefaultParameters": {
// "Temperature": 0.8,
// "TopP": 1,
// "MaxTokens": 500,
// "MaxCompletionTokens": null, // o1 series models support this property instead of MaxTokens
// "PresencePenalty": 0,
// "FrequencyPenalty": 0,
// "ResponseFormat": { "Type": "text" }, // Allowed values for Type: text (default) or json_object
// "Seed": 42 // Optional (any integer value)
//},
//"DefaultEmbeddingParameters": {
// "Dimensions": 1536
//}
}
Und dann die entsprechende Überladung von CHE -Addchatgpt -Methode:
// Adds ChatGPT service using settings from IConfiguration.
builder . Services . AddChatGpt ( builder . Configuration ) ;Die Addchatgpt -Methode hat auch eine Überlastung, die einen IserviceProvider als Argument akzeptiert. Wenn Sie beispielsweise in einer Web -API sind, kann es verwendet werden, und wir müssen Szenarien unterstützen, in denen jeder Benutzer einen anderen API -Schlüssel hat, der über die Abhängigkeitsinjektion auf eine Datenbank zugreifen kann:
builder . Services . AddChatGpt ( ( services , options ) =>
{
var accountService = services . GetRequiredService < IAccountService > ( ) ;
// Dynamically gets the API Key from the service.
var apiKey = " ... "
options . UseOpenAI ( apiKyey ) ;
} ) ;In komplexeren Szenarien ist es möglich, Chatgptnet sowohl mit Code als auch mit Symbolfiguration zu konfigurieren. Dies kann nützlich sein, wenn wir eine Reihe gemeinsamer Eigenschaften festlegen möchten. Gleichzeitig benötigen wir jedoch eine Konfigurationslogik. Zum Beispiel:
builder . Services . AddChatGpt ( ( services , options ) =>
{
// Configure common properties (message limit and expiration, default parameters, ecc.) using IConfiguration.
options . UseConfiguration ( builder . Configuration ) ;
var accountService = services . GetRequiredService < IAccountService > ( ) ;
// Dynamically gets the API Key from the service.
var apiKey = " ... "
options . UseOpenAI ( apiKyey ) ;
} ) ;Chatgptnet verwendet einen HTTPClient, um den Chat -Abschluss aufzurufen und APIs einzubetten. Wenn Sie es anpassen müssen, können Sie die Überlastung der Addchatgpt -Methode verwenden, die eine Aktion <IhttpclientBuiler> als Argument akzeptiert. Wenn Sie beispielsweise dem HTTP -Client Ausfallsicherheit hinzufügen möchten (sagen wir eine Wiederholungsrichtlinie), können Sie Polly verwenden:
// using Microsoft.Extensions.DependencyInjection;
// Requires: Microsoft.Extensions.Http.Resilience
builder . Services . AddChatGpt ( context . Configuration ,
httpClient =>
{
// Configures retry policy on the inner HttpClient using Polly.
httpClient . AddStandardResilienceHandler ( options =>
{
options . AttemptTimeout . Timeout = TimeSpan . FromMinutes ( 1 ) ;
options . CircuitBreaker . SamplingDuration = TimeSpan . FromMinutes ( 3 ) ;
options . TotalRequestTimeout . Timeout = TimeSpan . FromMinutes ( 3 ) ;
} ) ;
} )Weitere Informationen zu diesem Thema finden Sie in der offiziellen Dokumentation.
Die Bibliothek kann in jeder .NET -Anwendung verwendet werden, die mit .NET 6.0 oder höher erstellt wurde. Zum Beispiel können wir auf diese Weise eine minimale API erstellen:
app . MapPost ( " /api/chat/ask " , async ( Request request , IChatGptClient chatGptClient ) =>
{
var response = await chatGptClient . AskAsync ( request . ConversationId , request . Message ) ;
return TypedResults . Ok ( response ) ;
} )
. WithOpenApi ( ) ;
// ...
public record class Request ( Guid ConversationId , string Message ) ;Wenn wir nur die Antwortnachricht abrufen möchten, können wir die GetContent -Methode aufrufen:
var content = response . GetContent ( ) ;Beachten Sie , dass GetContent null zurückgibt, wenn die Antwort durch das Inhaltsfiltersystem filtriert wurde. Daher sollten Sie immer die
response.IsContentFilteredüberprüfen.
Mit der Konfiguration ist es möglich, Standardparameter für die Chat -Fertigstellung festzulegen. Wir können jedoch auch Parameter für jede Anforderung angeben, indem wir die AskaSync -Überladungen oder ABS -Streamasync -Überladungen verwenden, die ein ChatgptParameters -Objekt akzeptieren:
var response = await chatGptClient . AskAsync ( conversationId , message , new ChatGptParameters
{
MaxTokens = 150 ,
Temperature = 0.7
} ) ;Wir müssen nicht alle Parameter angeben, nur die, die wir überschreiben möchten. Die anderen werden aus der Standardkonfiguration entnommen.
Chatgpt ist als nicht deterministisch bekannt. Dies bedeutet, dass der gleiche Eingang unterschiedliche Ausgänge erzeugen kann. Um dieses Verhalten zu steuern, können wir die Temperatur- und Topp -Parameter verwenden. Wenn Sie beispielsweise die Temperatur auf Werte in der Nähe von 0 festlegen, macht das Modell das Modell deterministischer, während es auf Werte in der Nähe von 1 setzt, das Modell kreativer. Dies reicht jedoch nicht immer aus, um die gleiche Ausgabe für denselben Eingang zu erhalten. Um dieses Problem anzugehen, führte OpenAI den Saatgutparameter vor. Wenn angegeben, sollte das Modell deterministisch einteilen, so dass wiederholte Anforderungen mit denselben Saatgut und Parametern dasselbe Ergebnis zurückgeben sollten. Dennoch ist Determinismus in diesem Fall nicht garantiert, und Sie sollten sich auf den Parameter "Systemfingerabdruckantwort " beziehen, um Änderungen im Backend zu überwachen. Änderungen in diesen Werten bedeuten, dass sich die Backend -Konfiguration geändert hat, und dies kann sich auf den Determinismus auswirken.
Wie immer kann die Saatguteigenschaft in der Standardkonfiguration oder in der AskaSync oder in der Überlastung von ABSREAMAsync angegeben werden, die ein ChatgptParameters akzeptieren.
Hinweis Saatgut und Systemfingerabdruck werden nur von den neuesten Modellen wie GPT-4-1106-Präview unterstützt.
Wenn Sie die Antwort im JSON -Format vornehmen möchten, können Sie den Parameter ResponseFormat verwenden:
var response = await chatGptClient . AskAsync ( conversationId , message , new ChatGptParameters
{
ResponseFormat = ChatGptResponseFormat . Json ,
} ) ;Auf diese Weise wird die Antwort immer ein gültiger JSON sein. Beachten Sie, dass das Modell auch anweisen muss, JSON über ein System oder eine Benutzernachricht zu erstellen. Wenn Sie dies nicht tun, gibt das Modell einen Fehler zurück.
Wie immer kann die ResponseFormat -Eigenschaft in der Standardkonfiguration oder in der AskaSync oder in der Überlastung von ABSREAMASYNC angegeben werden, die ein ChatgptParameters akzeptieren.
Hinweis ResponseFormat wird nur von den neuesten Modellen wie GPT-4-1106-Präview unterstützt.
Die AskaSync und die ASKSTREAMASYNC -Methoden (siehe unten) enthält Überlastungen, die einen ConversationID -Parameter erfordern. Wenn wir einen leeren Wert übergeben, wird ein zufälliger generiert und zurückgegeben. Wir können diesen Wert in nachfolgenden Aufrufe von AskaSync oder ASKSTREAMASYNC übergeben, so dass die Bibliothek frühere Nachrichten der aktuellen Konversation automatisch abzurufen (je nach Einstellungen von Messagelimit und Messagexpiration ) und sie an die API CHAT -Abschluss senden.
Dies ist das Standardverhalten für alle Chat -Interaktionen. Wenn Sie eine bestimmte Interaktion aus der Konversationsgeschichte auslegen möchten, können Sie das Argument für AddtoconversationHistory auf false festlegen:
var response = await chatGptClient . AskAsync ( conversationId , message , addToConversationHistory : false ) ;Auf diese Weise wird die Nachricht an die Chat -Abschluss -API gesendet, aber die entsprechende Antwort von ChatGPT wird dem Gesprächsgeschichte nicht hinzugefügt.
Andererseits könnte es in einigen Szenarien nützlich sein, der Gesprächsgeschichte manuell eine Chat -Interaktion (dh eine Frage, gefolgt von einer Antwort) hinzuzufügen. Zum Beispiel möchten wir möglicherweise eine Nachricht hinzufügen, die von einem Bot generiert wurde. In diesem Fall können wir die AddInteractionAsync -Methode verwenden:
await chatGptClient . AddInteractionAsync ( conversationId , question : " What is the weather like in Taggia? " ,
answer : " It's Always Sunny in Taggia " ) ;Die Frage wird als Benutzernachricht hinzugefügt und die Antwort wird als Assistenznachricht im Gesprächsverlauf hinzugefügt. Wie immer werden diese neuen Nachrichten (die die Option MessAGelimit -Option respektieren) in nachfolgenden Aufrufe von AskaSync oder ABSSTREAMASYNC verwendet.
Die API von Chat Completion unterstützt das Antwort -Streaming. Bei der Verwendung dieser Funktion werden teilweise Nachrichten -Deltas wie in ChatGPT gesendet. Tokens werden als server-sent-Ereignisse nur für Daten gesendet, sobald sie verfügbar sind. ChatgptNet bietet ein Antwort -Streaming mithilfe der AssoteReamAsync -Methode:
// Requests a streaming response.
var responseStream = chatGptClient . AskStreamAsync ( conversationId , message ) ;
await foreach ( var response in responseStream )
{
Console . Write ( response . GetContent ( ) ) ;
await Task . Delay ( 80 ) ;
}Hinweis Wenn die Antwort durch das Inhaltsfiltersystem filtriert wurde, gibt die GetContent -Methode im Foreach Null -Zeichenfolgen zurück. Daher sollten Sie immer die
response.IsContentFilteredüberprüfen.
Response Streaming funktioniert, indem ein iAyncenumerable zurückgegeben wird, sodass es auch in einem Web -API -Projekt verwendet werden kann:
app . MapGet ( " /api/chat/stream " , ( Guid ? conversationId , string message , IChatGptClient chatGptClient ) =>
{
async IAsyncEnumerable < string ? > Stream ( )
{
// Requests a streaming response.
var responseStream = chatGptClient . AskStreamAsync ( conversationId . GetValueOrDefault ( ) , message ) ;
// Uses the "AsDeltas" extension method to retrieve partial message deltas only.
await foreach ( var delta in responseStream . AsDeltas ( ) )
{
yield return delta ;
await Task . Delay ( 50 ) ;
}
}
return Stream ( ) ;
} )
. WithOpenApi ( ) ;Hinweis Wenn die Antwort durch das Inhaltsfiltersystem filtriert wurde, gibt die Asdeltas -Methode im foreach die NULLS -Zeichenfolge zurück.
Die Bibliothek ist zu 100% kompatibel auch mit Blazor WebAssembly -Anwendungen:
Weitere Informationen zu den verschiedenen Implementierungen finden Sie im Sample -Ordner.
ChatGPT unterstützt Nachrichten mit der Systemrolle , um zu beeinflussen, wie sich der Assistent verhalten soll. Zum Beispiel können wir Chatgpt so etwas erkennen:
Chatgptnet bietet diese Funktion mithilfe der SetUpaSync -Methode:
var conversationId await = chatGptClient . SetupAsync ( " Answer in rhyme " ) ;Wenn wir beim Aufrufen von AskaSync dieselbe Konversation verwenden, wird die Systemnachricht automatisch zusammen mit jeder Anfrage gesendet, damit der Assistent weiß, wie er sich verhalten kann.
Beachten Sie, dass die Systemmeldung nicht für die Nachrichtenlimitnummer zählt.
Der Gesprächsverlauf wird automatisch gelöscht, wenn die Ablaufzeit (angegeben von Messagexpiration Property) erreicht ist. Bei Bedarf ist es jedoch möglich, die Geschichte sofort zu löschen:
await chatGptClient . DeleteConversationAsync ( conversationId , preserveSetup : false ) ;Das Argument für Preservesetup ermöglicht es zu entscheiden, ob Mantain auch die Systemmeldung , die mit der Setupasync -Methode festgelegt wurde (Standard: Falsch ).
Mit Funktionsaufruf können wir Funktionen beschreiben und das Modell intelligent ein JSON -Objekt ausgeben, das Argumente enthält, um diese Funktionen aufzurufen. Dies ist eine neue Möglichkeit, die Funktionen von GPTs zuverlässig mit externen Werkzeugen und APIs zu verbinden.
ChatgptNet unterstützt Funktionen vollständig, indem es eine Überladung der ASKASYNC -Methode bereitstellt, mit der Funktionsdefinitionen angegeben werden können. Wenn dieser Parameter geliefert wird, entscheidet das Modell, wann es angemessen ist, eine der Funktionen zu verwenden. Zum Beispiel:
var functions = new List < ChatGptFunction >
{
new ( )
{
Name = " GetCurrentWeather " ,
Description = " Get the current weather " ,
Parameters = JsonDocument . Parse ( """
{
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city and/or the zip code"
},
"format": {
"type": "string",
"enum": ["celsius", "fahrenheit"],
"description": "The temperature unit to use. Infer this from the user's location."
}
},
"required": ["location", "format"]
}
""" )
} ,
new ( )
{
Name = " GetWeatherForecast " ,
Description = " Get an N-day weather forecast " ,
Parameters = JsonDocument . Parse ( """
{
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city and/or the zip code"
},
"format": {
"type": "string",
"enum": ["celsius", "fahrenheit"],
"description": "The temperature unit to use. Infer this from the user's location."
},
"daysNumber": {
"type": "integer",
"description": "The number of days to forecast"
}
},
"required": ["location", "format", "daysNumber"]
}
""" )
}
} ;
var toolParameters = new ChatGptToolParameters
{
FunctionCall = ChatGptToolChoices . Auto , // This is the default if functions are present.
Functions = functions
} ;
var response = await chatGptClient . AskAsync ( " What is the weather like in Taggia? " , toolParameters ) ;Wir können eine willkürliche Anzahl von Funktionen übergeben, die jeweils einen Namen, eine Beschreibung und ein JSON -Schema, das die Funktionsparameter beschreibt, folgen den Referenzen des JSON -Schemas. Unter der Motorhaube werden Funktionen in eine Syntax in die Systemmeldung injiziert, auf der das Modell trainiert wurde. Dies bedeutet, dass Funktionen gegen die Kontextgrenze des Modells zählen und als Input -Token in Rechnung gestellt werden.
Das von der AskaSync -Methode zurückgegebene Antwortobjekt enthält eine Eigenschaft, um zu überprüfen, ob das Modell einen Funktionsaufruf ausgewählt hat:
if ( response . ContainsFunctionCalls ( ) )
{
Console . WriteLine ( " I have identified a function to call: " ) ;
var functionCall = response . GetFunctionCall ( ) ! ;
Console . WriteLine ( functionCall . Name ) ;
Console . WriteLine ( functionCall . Arguments ) ;
}Dieser Code druckt so etwas:
I have identified a function to call:
GetCurrentWeather
{
"location": "Taggia",
"format": "celsius"
}
Beachten Sie, dass die API keine Funktionsaufrufe ausführt. Es liegt an Entwicklern, Funktionsaufrufe mithilfe von Modellausgaben auszuführen.
Nach der tatsächlichen Ausführung müssen wir die addtoolreSeasync -Methode auf dem ChatgPTClient aufrufen, um die Antwort dem Gesprächsverlauf genau wie eine Standardnachricht hinzuzufügen, damit sie automatisch für den Chat -Abschluss verwendet wird:
// Calls the remote function API.
var functionResponse = await GetWeatherAsync ( functionCall . Arguments ) ;
await chatGptClient . AddToolResponseAsync ( conversationId , functionCall , functionResponse ) ;Neuere Modelle wie GPT-4-Turbo unterstützen einen allgemeineren Ansatz für Funktionen, das Tool-Anruf . Wenn Sie eine Anfrage senden, können Sie eine Liste von Tools angeben, die das Modell aufrufen kann. Derzeit werden nur Funktionen unterstützt, aber in zukünftiger Veröffentlichung werden andere Arten von Tools verfügbar sein.
Um das Tool -Aufruf anstelle eines direkten Funktionsaufrufs zu verwenden, müssen Sie die Eigenschaften von Toolchoice und Tools im Objekt ChatgptToolParameters festlegen (anstelle von Funktionen und Funktionen wie im vorherigen Beispiel):
var toolParameters = new ChatGptToolParameters
{
ToolChoice = ChatGptToolChoices . Auto , // This is the default if functions are present.
Tools = functions . ToTools ( )
} ;Die Totools -Erweiterungsmethode wird verwendet, um eine Liste von Chatgptfunktion in eine Liste von Tools umzuwandeln.
Wenn Sie diesen neuen Ansatz verwenden, müssen Sie natürlich noch überprüfen, ob das Modell einen Tool -Aufruf ausgewählt hat, indem Sie denselben Ansatz verwenden, der zuvor gezeigt wurde. Nach der tatsächlichen Ausführung der Funktion müssen Sie dann die Methode addtoolResponseasync aufrufen, in diesem Fall müssen Sie jedoch das Tool (nicht die Funktion) angeben, auf das sich die Antwort bezieht:
var tool = response . GetToolCalls ( ) ! . First ( ) ;
var functionCall = response . GetFunctionCall ( ) ! ;
// Calls the remote function API.
var functionResponse = await GetWeatherAsync ( functionCall . Arguments ) ;
await chatGptClient . AddToolResponseAsync ( conversationId , tool , functionResponse ) ;Schließlich müssen Sie die ursprüngliche Nachricht an die Chat Completion -API weitergeben, damit das Modell die Konversation unter Berücksichtigung der Funktionsaufrufantwort fortsetzen kann. Schauen Sie sich die Funktion an, die die Funktion aufruft, um eine vollständige Implementierung dieses Workflows zu erhalten.
Bei der Verwendung von Azure OpenAI -Service erhalten wir automatisch kostenlos Inhaltsfilterung. Weitere Informationen zum Funktionieren finden Sie in der Dokumentation. Diese Informationen werden für alle Szenarien zurückgegeben, wenn sie die API-Version 2023-06-01-preview oder später verwenden. Chatgptnet unterstützt dieses Objektmodell voll und ganz, indem sie die entsprechenden Eigenschaften in den Klassen ChatgpTeResponse und ChatgptChoice bereitstellen.
Durch Einbettungen können Text in einen Vektorraum umwandeln. Dies kann nützlich sein, um beispielsweise die Ähnlichkeit zweier Sätze zu vergleichen. Chatgptnet unterstützt diese Funktion vollständig, indem sie die GetembeddingAsync -Methode bereitstellt:
var response = await chatGptClient . GenerateEmbeddingAsync ( message ) ;
var embeddings = response . GetEmbedding ( ) ;Dieser Code gibt Ihnen ein Float -Array, das alle Einbettungen für die angegebene Nachricht enthält. Die Länge des Arrays hängt vom verwendeten Modell ab:
| Modell | Ausgangsdimension |
|---|---|
| Text-Embedding-ada-002 | 1536 |
| Text-Embedding-3-Small | 1536 |
| Text-Embedding-3-Large | 3072 |
Neuere Modelle wie Text-Embedding-3-Small und Text-Embedding-3-Large ermöglichen es Entwicklern, die Leistung und die Kosten für die Verwendung von Einbettungen zu verwenden. Insbesondere können Entwickler Einbettungen verkürzen, ohne dass die Einbettung der Konzeptrepräsentation Eigenschaften verliert.
Für ChatGPT können diese Einstellungen auf verschiedene Weise durchgeführt werden:
builder . Services . AddChatGpt ( options =>
{
// ...
options . DefaultEmbeddingParameters = new EmbeddingParameters
{
Dimensions = 256
} ;
} ) ; "ChatGPT": {
"DefaultEmbeddingParameters": {
"Dimensions": 256
}
}
Wenn Sie dann die Dimension für eine bestimmte Anfrage ändern möchten, können Sie das Argument für Einbettungsparameter im Aufruf von GetembeddingaSync angeben:
var response = await chatGptClient . GenerateEmbeddingAsync ( request . Message , new EmbeddingParameters
{
Dimensions = 512
} ) ;
var embeddings = response . GetEmbedding ( ) ; // The length of the array is 512Wenn Sie die Kosinus -Ähnlichkeit zwischen zwei Einbettungen berechnen müssen, können Sie die Einbettungsdessilitätsmethode verwenden.
Die vollständige technische Dokumentation finden Sie hier.
Das Projekt entwickelt sich ständig weiter. Beiträge sind willkommen. Fühlen Sie sich frei, Probleme zu stellen und Anfragen auf das Repo zu ziehen, und wir werden sie so ansprechen, wie wir können.
Warnung Denken Sie daran, an der Entwicklungszweig zu arbeiten. Verwenden Sie den Master -Zweig nicht direkt. Erstellen Sie Pull -Anfragen Targeting -Entwicklung .
