Verwenden Sie Mistral AI, um generative KI-Anwendungen mit Go zu erstellen

In den Ausgabeprotokollen oben sehen Sie, wie die Token wird interpretiert

type MistralRequest struct {
    Prompt        string   `json:"prompt"`
    MaxTokens     int      `json:"max_tokens,omitempty"`
    Temperature   float64  `json:"temperature,omitempty"`
    TopP          float64  `json:"top_p,omitempty"`
    TopK          int      `json:"top_k,omitempty"`
    StopSequences []string `json:"stop,omitempty"`
}

    output, err := brc.InvokeModel(context.Background(), &bedrockruntime.InvokeModelInput{
        Body:        payloadBytes,
        ModelId:     aws.String(modelID7BInstruct),
        ContentType: aws.String("application/json"),
    })

    var resp MistralResponse

    err = json.Unmarshal(output.Body, &resp)

    fmt.Println("response string:\n", resp.Outputs[0].Text)

Weiter zu einer einfachen Gesprächsinteraktion. Mistral bezeichnet dies als Multi-Turn-Eingabeaufforderung und wir werden das hinzufügen. Das ist das Ende der Zeichenfolge-Token.

Um das Beispiel auszuführen:

go run chat/main.go

Hier ist meine Interaktion:

Den vollständigen Code finden Sie hier

Der Code selbst ist für die Zwecke dieses Beispiels zu stark vereinfacht. Ein wichtiger Teil ist jedoch die Art und Weise, wie die Token zum Formatieren der Eingabeaufforderung verwendet werden. Beachten Sie, dass wir in diesem Beispiel Mixtral 8X7B (mistral.mixtral-8x7b-instruct-v0:1) verwenden.

const userMessageFormat = "[INST] %s [/INST]"
const modelID8X7BInstruct = "mistral.mixtral-8x7b-instruct-v0:1"
const bos = "<s>" 
const eos = "</s>"

var verbose *bool

func main() {
    reader := bufio.NewReader(os.Stdin)

    first := true
    var msg string

    for {
        fmt.Print("\nEnter your message: ")

        input, _ := reader.ReadString('\n')
        input = strings.TrimSpace(input)

        if first {
            msg = bos + fmt.Sprintf(userMessageFormat, input)
        } else {
            msg = msg + fmt.Sprintf(userMessageFormat, input)
        }

        payload := MistralRequest{
            Prompt: msg,
        }

        response, err := send(payload)

        fmt.Println("[Assistant]:", response)

        msg = msg + response + eos + " "

        first = false
    }
}

Das Token Anfang der Zeichenfolge (bos) wird nur einmal zu Beginn der Konversation benötigt, während eos (Ende der Zeichenfolge) das Ende markiert eines einzelnen Gesprächsaustauschs (Benutzer und Assistent).

Chatten Sie mit Streaming

Wenn Sie meine vorherigen Blogs gelesen haben, füge ich immer gerne ein „Streaming“-Beispiel hinzu, weil:

1. Es bietet eine bessere Erfahrung aus Sicht der Kundenanwendung
2. Es ist ein häufiger Fehler, die InvokeModelWithResponseStream-Funktion (das asynchrone Gegenstück zu InvokeModel) zu übersehen
3. Die partielle Modellnutzlastantwort kann interessant (und manchmal knifflig) sein

Den vollständigen Code finden Sie hier

Lass uns das ausprobieren. In diesem Beispiel wird Mistral Large verwendet – ändern Sie einfach die Modell-ID in mistral.mistral-large-2402-v1:0. Um das Beispiel auszuführen:

go run chat-streaming/main.go

Beachten Sie die Verwendung von InvokeModelWithResponseStream (anstelle von Invoke):

    output, err := brc.InvokeModelWithResponseStream(context.Background(), &bedrockruntime.InvokeModelWithResponseStreamInput{
        Body:        payloadBytes,
        ModelId:     aws.String(modelID7BInstruct),
        ContentType: aws.String("application/json"),
    })
    //...

Um die Ausgabe zu verarbeiten, verwenden wir:

    //...
    resp, err := processStreamingOutput(output, func(ctx context.Context, part []byte) error {
        fmt.Print(string(part))
        return nil
    })

Hier sind ein paar Teile der Funktion „processStreamingOutput“ – Sie können den Code hier überprüfen. Es ist wichtig zu verstehen, wie die Teilantworten gesammelt werden, um die endgültige Ausgabe (MistralResponse) zu erzeugen.

func processStreamingOutput(output *bedrockruntime.InvokeModelWithResponseStreamOutput, handler StreamingOutputHandler) (MistralResponse, error) {

    var combinedResult string

    resp := MistralResponse{}
    op := Outputs{}

    for event := range output.GetStream().Events() {
        switch v := event.(type) {
        case *types.ResponseStreamMemberChunk:

            var pr MistralResponse

            err := json.NewDecoder(bytes.NewReader(v.Value.Bytes)).Decode(&pr)
            if err != nil {
                return resp, err
            }

            handler(context.Background(), []byte(pr.Outputs[0].Text))

            combinedResult += pr.Outputs[0].Text
            op.StopReason = pr.Outputs[0].StopReason
    //...
    }

    op.Text = combinedResult
    resp.Outputs = []Outputs{op}

    return resp, nil
}

Abschluss

Denken Sie daran: Das Erstellen von KI/ML-Anwendungen mit großen Sprachmodellen (wie Mistral, Meta Llama, Claude usw.) bedeutet nicht, dass Sie Python verwenden müssen. Verwaltete Plattformen wie Amazon Bedrock bieten Zugriff auf diese leistungsstarken Modelle mithilfe flexibler APIs in einer Vielzahl von Programmiersprachen, einschließlich Go! Dank der AWS SDK-Unterstützung können Sie die Programmiersprache Ihrer Wahl für die Integration in Amazon Bedrock verwenden und generative KI-Lösungen erstellen.

Weitere Informationen finden Sie in der offiziellen Mistral-Dokumentation sowie im Amazon Bedrock-Benutzerhandbuch. Viel Spaß beim Bauen!

Das obige ist der detaillierte Inhalt vonVerwenden Sie Mistral AI, um generative KI-Anwendungen mit Go zu erstellen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!