Gunakan Mistral AI untuk membina aplikasi AI generatif dengan Go

Ketahui cara menggunakan Mistral AI pada Amazon Bedrock dengan AWS SDK for Go

Mistral AI menawarkan model dengan ciri yang berbeza-beza merentas prestasi, kos dan banyak lagi:

• Mistral 7B - Model padat pertama dikeluarkan oleh Mistral AI, sesuai untuk percubaan, penyesuaian dan lelaran pantas.
• Mixtral 8x7B - Campuran jarang model pakar.
• Mistral Large - sesuai untuk tugas kompleks yang memerlukan keupayaan penaakulan yang besar atau sangat khusus (Penjanaan Teks Sintetik, Penjanaan Kod, RAG atau Ejen).

Mari kita lihat cara menggunakan model AI Mistral ini di Amazon Bedrock dengan Go, dan dalam proses itu, juga dapatkan pemahaman yang lebih baik tentang token segeranya.

Bermula dengan Mistral AI

Mari kita mulakan dengan contoh mudah menggunakan Mistral 7B.

Rujuk bahagian **Sebelum Anda Bermula* dalam catatan blog ini untuk melengkapkan prasyarat untuk menjalankan contoh. Ini termasuk memasang Go, mengkonfigurasi akses Amazon Bedrock dan menyediakan kebenaran IAM yang diperlukan.*

Anda boleh rujuk kod lengkap di sini

Untuk menjalankan contoh:

git clone https://github.com/abhirockzz/mistral-bedrock-go
cd mistral-bedrock-go

go run basic/main.go

Respons mungkin (atau mungkin tidak) berbeza sedikit dalam kes anda:

request payload:
 {"prompt":"\u003cs\u003e[INST] Hello, what's your name? [/INST]"}
response payload:
 {"outputs":[{"text":" Hello! I don't have a name. I'm just an artificial intelligence designed to help answer questions and provide information. How can I assist you today?","stop_reason":"stop"}]}
response string:
  Hello! I don't have a name. I'm just an artificial intelligence designed to help answer questions and provide information. How can I assist you today?

Anda boleh rujuk kod lengkap di sini.

Kita mulakan dengan mencipta muatan JSON - ia dimodelkan sebagai struct (MistralRequest). Juga, perhatikan ID model mistral.mistral-7b-instruct-v0:2

const modelID7BInstruct = "mistral.mistral-7b-instruct-v0:2"
const promptFormat = "<s>[INST] %s [/INST]"

func main() {
    msg := "Hello, what's your name?"

    payload := MistralRequest{
        Prompt: fmt.Sprintf(promptFormat, msg),
    }
//...

Mistral mempunyai format gesaan khusus, di mana:

• merujuk kepada permulaan rentetan token
• teks untuk peranan pengguna berada di dalam token [INST]...[/INST]
• teks di luar ialah peranan pembantu

Dalam log keluaran di atas, lihat cara token ditafsirkan

Berikut ialah struct MistralRequest yang mempunyai atribut yang diperlukan:

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"`
}

InvokeModel digunakan untuk memanggil model. Respons JSON ditukar kepada struct (MistralResponse) dan respons teks diekstrak daripadanya.

    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)

Contoh sembang

Beralih kepada interaksi perbualan yang mudah. Inilah yang Mistral rujuk sebagai gesaan berbilang pusingan dan kami akan menambah yang merupakan tanda hujung rentetan.

Untuk menjalankan contoh:

go run chat/main.go

Ini interaksi saya:

Anda boleh rujuk kod lengkap di sini

Kod itu sendiri terlalu dipermudahkan untuk tujuan contoh ini. Tetapi, bahagian penting ialah cara token digunakan untuk memformat gesaan. Ambil perhatian bahawa kami menggunakan Mixtral 8X7B (mistral.mixtral-8x7b-instruct-v0:1) dalam contoh ini.

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
    }
}

Token permulaan rentetan (bos) hanya diperlukan sekali pada permulaan perbualan, manakala eos (tamat rentetan) menandakan penamat daripada satu pertukaran perbualan (pengguna dan pembantu).

Berbual dengan penstriman

Jika anda telah membaca blog saya sebelum ini, saya sentiasa suka menyertakan contoh "penstriman" kerana:

1. Ia memberikan pengalaman yang lebih baik dari sudut aplikasi pelanggan
2. Adalah satu kesilapan biasa untuk mengabaikan fungsi InvokeModelWithResponseStream (rakan sejawatan daripada InvokeModel)
3. Respon muatan model separa boleh menjadi menarik (dan kadangkala rumit)

Anda boleh rujuk kod lengkap di sini

Jom cuba ini. Contoh ini menggunakan Mistral Large - cuma tukar ID model kepada mistral.mistral-large-2402-v1:0. Untuk menjalankan contoh:

go run chat-streaming/main.go

Perhatikan penggunaan InvokeModelWithResponseStream (bukannya Invoke):

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

Untuk memproses outputnya, kami menggunakan:

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

Berikut adalah beberapa bit daripada fungsi processStreamingOutput - anda boleh menyemak kod di sini. Perkara penting untuk difahami ialah bagaimana respons separa dikumpul bersama untuk menghasilkan output akhir (MistralResponse).

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
}

Kesimpulan

Ingat - membina aplikasi AI/ML menggunakan Model Bahasa Besar (seperti Mistral, Meta Llama, Claude, dll.) tidak membayangkan bahawa anda perlu menggunakan Python. Platform terurus seperti Amazon Bedrock menyediakan akses kepada model berkuasa ini menggunakan API fleksibel dalam pelbagai bahasa pengaturcaraan, termasuk Go! Terima kasih kepada sokongan AWS SDK, anda boleh menggunakan bahasa pengaturcaraan pilihan anda untuk disepadukan dengan Amazon Bedrock, dan membina penyelesaian AI generatif.

Anda boleh mengetahui lebih lanjut dengan menerokai dokumentasi rasmi Mistral serta panduan pengguna Amazon Bedrock. Selamat membina!

Atas ialah kandungan terperinci Gunakan Mistral AI untuk membina aplikasi AI generatif dengan Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!