Membina Awan Ollama - Menskalakan Inferens Setempat kepada Awan

Ollama terutamanya pembungkus llama.cpp, direka untuk tugas inferens setempat. Ini biasanya bukan pilihan pertama anda jika anda mencari prestasi aMembina Awan Ollama - Menskalakan Inferens Setempat kepada Awan ciri yang canggih, tetapi ia mempunyai kegunaannya, terutamanya dalam persekitaran yang kebergantungan luaran menjadi kebimbangan.

Pembangunan AI Tempatan

Apabila menggunakan Ollama untuk pembangunan AI tempatan, persediaan adalah mudah tetapi berkesan. Pembangun biasanya memanfaatkan Ollama untuk menjalankan tugas inferens secara langsung pada mesin tempatan mereka. Berikut ialah gambaran visual persediaan pembangunan tempatan biasa menggunakan Ollama:

Konfigurasi ini membolehkan pembangun menguji dan mengulang dengan cepat tanpa kerumitan komunikasi pelayan jauh. Ia sesuai untuk fasa prototaip dan pembangunan awal yang pemulihan pantas adalah kritikal.

Dari Tempatan ke Awan

Peralihan daripada persediaan setempat kepada persekitaran awan berskala melibatkan perubahan daripada persediaan 1:1 yang mudah (satu permintaan pengguna kepada satu hos inferens) kepada konfigurasi banyak-ke-banyak (berbilang permintaan pengguna kepada hos inferens berbilang) yang lebih kompleks . Peralihan ini perlu untuk mengekalkan kecekapan dan responsif apabila permintaan meningkat.

Begini rupa penskalaan ini apabila beralih daripada pembangunan tempatan kepada pengeluaran:

Mengguna pakai pendekatan mudah semasa peralihan ini boleh meningkatkan kerumitan aplikasi dengan ketara, terutamanya kerana sesi perlu mengekalkan konsistensi merentas pelbagai negeri. Kelewatan dan ketidakcekapan mungkin timbul jika permintaan tidak dihalakan secara optimum ke hos inferens terbaik yang tersedia.

Selain itu, sifat kompleks aplikasi yang diedarkan menjadikan aplikasi itu mencabar untuk diuji secara tempatan, yang boleh melambatkan proses pembangunan dan meningkatkan risiko kegagalan dalam persekitaran pengeluaran.

Tanpa pelayan

Pengkomputeran tanpa pelayan mengabstrakkan pengurusan pelayan dan butiran infrastruktur, membolehkan pembangun menumpukan pada kod dan logik perniagaan semata-mata. Dengan menyahganding pengendalian permintaan dan penyelenggaraan konsisten daripada aplikasi, seni bina tanpa pelayan memudahkan penskalaan.

Pendekatan ini membolehkan aplikasi kekal tertumpu pada penyampaian nilai, menyelesaikan banyak cabaran penskalaan biasa tanpa membebankan pembangun dengan kerumitan infrastruktur.

WebAssembly

WebAssembly (Wasm) menangani cabaran pengurusan pergantungan dengan membolehkan penyusunan aplikasi ke dalam modul serba lengkap. Ini menjadikan apl lebih mudah untuk diatur dan diuji secara tempatan dan dalam awan, memastikan konsistensi merentas persekitaran yang berbeza.

Tau

Tau ialah rangka kerja untuk membina platform pengkomputeran awan penyelenggaraan rendah dan berskala tinggi. Ia cemerlang dalam kesederhanaan dan kebolehlanjutan. Tau menjadikan penggunaan mudah dan menyokong menjalankan awan tempatan untuk pembangunan, membenarkan ujian hujung ke hujung (E2E) bagi kedua-dua infrastruktur awan dan aplikasi yang dijalankan padanya.

Pendekatan ini, yang dirujuk oleh Taubyte sebagai "Pengekodan Tempatan Sama dengan Pengeluaran Global," memastikan bahawa apa yang berfungsi secara tempatan akan berfungsi secara global, dengan ketara memudahkan proses pembangunan dan penggunaan.

Mengintegrasikan Ollama ke dalam Tau dengan Sistem Pemalam Orbit

Sistem pemalam Tau, dikenali sebagai Orbit, memudahkan dengan ketara menukar perkhidmatan kepada komponen yang boleh diurus dengan membungkusnya ke dalam modul hos WebAssembly. Pendekatan ini membolehkan Tau mengambil alih tugas orkestrasi, menyelaraskan proses penempatan dan pengurusan.

Fungsi Mengeksport dalam Ollama

Untuk menjadikan fungsi Ollama boleh diakses dalam ekosistem Tau, kami menggunakan sistem Orbit untuk mengeksport keupayaan Ollama sebagai titik akhir yang boleh dipanggil. Begini cara anda boleh mengeksport titik akhir dalam Go:

func (s *ollama) W_pull(ctx context.Context, module satellite.Module, modelNamePtr uint32, modelNameSize uint32, pullIdptr uint32) Error {
    model, err := module.ReadString(modelNamePtr, modelNameSize)
    if err != nil {
        return ErrorReadMemory
    }

    id, updateFunc := s.getPullId(model)

    if updateFunc != nil {
        go func() {
            err = server.PullModel(s.ctx, model, &server.RegistryOptions{}, updateFunc)
            s.pullLock.Lock()
            defer s.pullLock.Unlock()
            s.pulls[id].err = err
        }()
    }

    module.WriteUint64(pullIdptr, id)

    return ErrorNone
}

Untuk contoh mudah fungsi mengeksport, anda boleh merujuk kepada contoh hello_world.

Setelah ditakrifkan, fungsi ini, kini dipanggil melalui satelit. Eksport, membolehkan penyepaduan lancar Ollama ke dalam persekitaran Tau:

func main() {
    server := new(context.TODO(), "/tmp/ollama-wasm")
    server.init()
    satellite.Export("ollama", server)
}

Ujian Menulis untuk Pemalam Ollama

Menguji pemalam adalah diperkemas dan mudah. Begini cara anda boleh menulis ujian fungsi tanpa pelayan dalam Go:

//export pull
func pull() {
    var id uint64
    err := Pull("gemma:2b-instruct", &id)
    if err != 0 {
        panic("failed to call pull")
    }
}

Menggunakan suite ujian Tau dan alat pembangun Go, anda boleh membina pemalam anda, menggunakan ia dalam persekitaran ujian dan melaksanakan fungsi tanpa pelayan untuk mengesahkan kefungsian:

func TestPull(t *testing.T) {
    ctx := context.Background()

    // Create a testing suite to test the plugin
    ts, err := suite.New(ctx)
    assert.NilError(t, err)

    // Use a Go builder to build plugins and wasm
    gob := builder.New()

    // Build the plugin from the directory
    wd, _ := os.Getwd()
    pluginPath, err := gob.Plugin(path.Join(wd, "."), "ollama")
    assert.NilError(t, err)

    // Attach plugin to the testing suite
    err = ts.AttachPluginFromPath(pluginPath)
    assert.NilError(t, err)

    // Build a wasm file from serverless function
    wasmPath, err := gob.Wasm(ctx, path.Join(wd, "fixtures", "pull.go"), path.Join(wd, "fixtures", "common.go"))
    assert.NilError(t, err)

    // Load the wasm module and call the function
    module, err := ts.WasmModule(wasmPath)
    assert.NilError(t, err)

    // Call the "pull" function from our wasm module
    _, err = module.Call(ctx, "pull")
    assert.NilError(t, err)
}

Code

You can find the complete code here https://github.com/ollama-cloud/ollama-as-wasm-plugin/tree/main/Membina Awan Ollama - Menskalakan Inferens Setempat kepada Awan

What's Next?

You can now build LLM applications with ease. Here are the steps to get started:

• Start locally using dream: Set up your local environment to develop and test your application.
• Create a project: Begin a new project with Tau to harness its full potential.
• Create your production cloud: Deploy your project in a production cloud environment.
• Drop the plugin binary in the /tb/plugins folder.
• Import your project into production
• Show off!

Atas ialah kandungan terperinci Membina Awan Ollama - Menskalakan Inferens Setempat kepada Awan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!