SDK untuk Go - Platform For AI

SDK Resmi Elastic Algorithm Service (EAS) disediakan untuk memanggil layanan yang diterapkan berdasarkan model mereka. SDK EAS mengurangi waktu yang diperlukan untuk mendefinisikan logika pemanggilan dan meningkatkan stabilitas pemanggilan. Topik ini menjelaskan EAS SDK untuk Go. Demo disediakan untuk menunjukkan cara menggunakan EAS SDK untuk Go memanggil layanan. Dalam demo ini, input dan output adalah tipe yang umum digunakan.

Informasi latar belakang

Anda tidak perlu menginstal EAS SDK untuk Go terlebih dahulu. SDK secara otomatis diunduh dari GitHub oleh manajer paket bahasa GO selama kompilasi kode. Untuk menyesuaikan bagian tertentu dari logika pemanggilan, Anda dapat mengunduh EAS SDK untuk Go dan memodifikasi kode. Untuk mengunduh SDK, kunjungi eas-golang-sdk.

Metode

Kelas	Metode	Deskripsi
PredictClient	`NewPredictClient(endpoint string, serviceName string) *PredictClient`	Membuat objek klien dari kelas PredictClient. Parameter: endpoint: wajib. Titik akhir server. Untuk memanggil layanan dalam mode reguler, atur parameter ini ke titik akhir gateway default. serviceName: wajib. Nama layanan yang akan dipanggil. Nilai kembali: objek klien yang dibuat.
	`SetEndpoint(endpointName string)`	Menentukan titik akhir server. Parameter: endpointName: titik akhir server. Untuk memanggil layanan dalam mode reguler, atur parameter ini ke titik akhir gateway default.
	`SetServiceName(serviceName string)`	Menentukan nama layanan. Parameter: serviceName: nama layanan.
	`SetEndpointType(endpointType string)`	Menentukan tipe gateway server. Parameter: endpointType: tipe gateway yang akan digunakan. Tipe gateway berikut didukung: "DEFAULT": gateway default. Jika Anda tidak menentukan tipe gateway, gateway default yang digunakan. "DIRECT": Saluran koneksi langsung Virtual Private Cloud (VPC).
	`SetToken(token string)`	Menentukan token akses layanan. Parameter: token: token yang digunakan untuk mengotentikasi layanan.
	`SetHttpTransport(transport *http.Transport)`	Mengatur atribut transport HTTP client. Parameter: transport: objek transport yang digunakan untuk mengirim permintaan HTTP.
	`SetRetryCount(max_retry_count int)`	Menentukan jumlah maksimum percobaan ulang setelah kegagalan permintaan. Parameter: max_retry_count: jumlah maksimum percobaan ulang setelah kegagalan permintaan. Nilai default: 5. Penting Klien harus mengirim ulang permintaan jika terjadi kesalahan proses di server, kesalahan server, atau koneksi persisten ke gateway ditutup. Oleh karena itu, kami sarankan agar Anda tidak mengatur parameter ini ke 0.
	`SetTimeout(timeout int)`	Mengatur periode timeout permintaan. Parameter: timeout: periode timeout permintaan. Unit: milidetik. Nilai default: 5000.
	`Init()`	Menginisialisasi objek klien. Saat salah satu metode sebelumnya yang digunakan untuk menetapkan parameter dipanggil, parameter tersebut tidak berlaku sampai Anda memanggil metode `Init()`.
	`Predict(request Request) Response`	Mengirim permintaan prediksi ke layanan prediksi online. Parameter: Request: permintaan yang akan dikirim. Bisa berupa string, objek TFRequest, atau objek TorchRequest. Nilai kembali: respons terhadap permintaan prediksi. Bisa berupa string, objek TFResponse, atau objek TorchResponse.
	`StringPredict(request string) string`	Mengirim permintaan prediksi ke layanan prediksi online. Parameter: request: string permintaan yang akan dikirim. Nilai kembali: respons terhadap permintaan prediksi, dikembalikan sebagai string.
	`TorchPredict(request TorchRequest) TorchResponse`	Mengirim permintaan prediksi PyTorch ke layanan prediksi online. Parameter: request: permintaan yang akan dikirim, yang merupakan objek TorchRequest. Nilai kembali: respons terhadap permintaan prediksi. Ini adalah objek TorchResponse.
	`TFPredict(request TFRequest) TFResponse`	Mengirim permintaan prediksi ke layanan prediksi online. Parameter: request: permintaan yang akan dikirim, yang merupakan objek TFRequest. Nilai kembali: respons terhadap permintaan prediksi. Ini adalah objek TFResponse.
TFRequest	`TFRequest(signatureName string)`	Membuat objek dari kelas TFRequest. Parameter: signatureName: nama tanda tangan model layanan yang akan dipanggil.
	`AddFeed(?)(inputName string, shape []int64{}, content []?)`	Menentukan tensor input model TensorFlow dari layanan prediksi online yang akan dipanggil. Parameter: inputName: alias tensor input. shape: bentuk tensor input. content: data tensor input. Tentukan nilai dalam bentuk array satu dimensi. Tipe data bisa INT32, INT64, FLOAT32, FLOAT64, STRING, atau BOOL. Nama metode ini ditentukan oleh tipe data spesifik yang digunakan. Contoh: `AddFeedInt32()`. Jika Anda ingin menggunakan tipe data lain, konstruksikan dalam format protocol buffer (PB) berdasarkan kode yang diberikan.
	`AddFetch(outputName string)`	Menentukan alias tensor output yang akan diekspor dari model TensorFlow. Parameter: outputName: alias tensor output yang akan diekspor. Jika model TensorFlow dalam format SavedModel, parameter ini opsional. Jika parameter ini tidak ditentukan, semua tensor output diekspor. Jika model TensorFlow adalah model beku, parameter ini wajib.
TFResponse	`GetTensorShape(outputName string) []int64`	Meminta bentuk tensor output yang diidentifikasi oleh alias tertentu. Parameter: outputName: alias tensor output yang ingin Anda periksa. Nilai kembali: bentuk tensor output. Setiap dimensi ditampilkan sebagai array.
TFResponse	`Get(?)Val(outputName string) [](?)`	Meminta data tensor output tertentu. Nilai kembali adalah array satu dimensi. Anda dapat memanggil metode ini bersama dengan metode `GetTensorShape()` untuk meminta bentuk tensor output. Nilai kembali adalah array multi-dimensi. Tipe data bisa FLOAT, DOUBLE, INT, INT64, STRING, atau BOOL. Nama metode ini ditentukan oleh tipe data spesifik yang digunakan. Contoh: `GetFloatVal()`. Parameter: outputName: alias tensor output yang ingin Anda periksa. Nilai kembali: array satu dimensi yang dikonversi dari data tensor output yang diperoleh.
TorchRequest	`TorchRequest()`	Membuat objek dari kelas TFRequest.
	`AddFeed(?)(index int, shape []int64{}, content []?)`	Menentukan tensor input model PyTorch dari layanan prediksi online yang akan dipanggil. Parameter: index: indeks tensor input. shape: bentuk tensor input. content: data tensor input. Tentukan nilai dalam bentuk array satu dimensi. Tipe data bisa INT32, INT64, FLOAT32, atau FLOAT64. Nama metode ini ditentukan oleh tipe data spesifik yang digunakan. Contoh: `AddFeedInt32()`. Jika Anda ingin menggunakan tipe data lain, konstruksikan dalam format protocol buffer (PB) berdasarkan kode yang diberikan.
	`AddFetch(outputIndex int)`	Menentukan indeks tensor output yang akan diekspor dari model PyTorch. Metode ini opsional. Jika Anda tidak memanggil metode ini untuk menetapkan indeks tensor output, semua tensor output diekspor. Parameter: outputIndex: indeks tensor output yang akan diekspor.
TorchResponse	`GetTensorShape(outputIndex int) []int64`	Meminta bentuk tensor output yang diidentifikasi oleh indeks tertentu. Parameter: outputIndex: indeks tensor output. Nilai kembali: bentuk tensor output. Setiap dimensi ditampilkan sebagai array.
TorchResponse	`Get(?)Val(outputIndex int) [](?)`	Meminta data tensor output tertentu. Nilai kembali adalah array satu dimensi. Anda dapat memanggil metode ini bersama dengan metode `GetTensorShape()` untuk memperoleh bentuk tensor output. Nilai kembali adalah array multi-dimensi. Tipe data bisa FLOAT, DOUBLE, INT, atau INT64. Nama metode ini ditentukan oleh tipe data spesifik yang digunakan. Contoh: `GetFloatVal()`. Parameter: outputName: indeks tensor output yang ingin Anda periksa. Nilai kembali: array satu dimensi yang dikonversi dari data tensor output yang diperoleh.
QueueClient	`NewQueueClient(endpoint, queueName, token string) (*QueueClient, error)`	Membuat objek klien dari kelas QueueClient. Parameter: endpoint: titik akhir server. queueName: nama antrian yang akan dibuat. token: token antrian yang akan dibuat. Nilai kembali: objek klien yang dibuat.
	`Truncate(ctx context.Context, index uint64) error`	Memotong data sebelum nilai indeks tertentu dan hanya menyimpan data setelah nilai indeks. Parameter: ctx: konteks operasi ini. index: nilai indeks yang digunakan untuk memotong data.
	`Put(ctx context.Context, data []byte, tags types.Tags) (index uint64, requestId string, err error)`	Menulis catatan data ke antrian. Parameter: ctx: konteks operasi ini. data: catatan data yang ingin Anda tulis ke antrian. Nilai kembali: index: nilai indeks catatan data yang ditulis. Nilai ini dapat digunakan untuk meminta data dalam antrian. requestId: ID permintaan yang dihasilkan secara otomatis untuk catatan data yang ditulis dalam antrian. requestId dapat digunakan sebagai tag khusus untuk meminta data dalam antrian.
	`GetByIndex(ctx context.Context, index uint64) (dfs []types.DataFrame, err error)`	Meminta catatan data dari antrian berdasarkan nilai indeks catatan dan kemudian menghapus catatan tersebut. Parameter: ctx: konteks operasi ini. index: nilai indeks catatan data yang ingin Anda periksa. Nilai kembali: dfs: catatan data yang diperoleh dalam format DataFrame.
	`GetByRequestId(ctx context.Context, requestId string) (dfs []types.DataFrame, err error)`	Meminta catatan data dari antrian berdasarkan ID permintaan catatan dan kemudian menghapus catatan tersebut. Parameter: ctx: konteks operasi ini. requestId: ID permintaan catatan data yang ingin Anda periksa. Nilai kembali: dfs: catatan data yang diperoleh dalam format DataFrame.
	`Get(ctx context.Context, index uint64, length int, timeout time.Duration, autoDelete bool, tags types.Tags) (dfs []types.DataFrame, err error)`	Meminta data dalam antrian berdasarkan kondisi tertentu. Metode `GetByIndex()` dan `GetByRequestId()` adalah enkapsulasi dari metode `get()`. Parameter: ctx: konteks operasi ini. index: indeks awal untuk meminta. length: jumlah catatan data untuk meminta. Jika parameter ini ditentukan, jumlah maksimum catatan data mulai dari indeks dikembalikan. Catatan data yang sesuai dengan nilai indeks juga dikembalikan. timeout: periode timeout permintaan. Selama periode timeout, jika antrian berisi data, jumlah catatan data yang memenuhi kondisi tertentu dikembalikan. Jika tidak, permintaan berhenti setelah periode timeout selesai. auto_delete: menentukan apakah akan menghapus catatan data yang diperoleh dari antrian secara otomatis. Jika Anda mengatur auto_delete ke False, catatan data dapat diperiksa berulang kali. Dalam hal ini, Anda dapat menggunakan metode `Del()` untuk menghapus data secara manual. tags: tag yang digunakan untuk meminta catatan data. Kunci dan nilai tag harus berupa tipe STRING. Jika parameter ini ditentukan, catatan data mulai dari indeks yang ditambahkan dengan tag tertentu akan dikembalikan. Nilai kembali: dfs: catatan data yang diperoleh dalam format DataFrame.
	`Del(ctx context.Context, indexes ...uint64)`	Menghapus catatan data yang sesuai dengan nilai indeks tertentu dari antrian. Parameter: ctx: konteks operasi ini. indexes: nilai indeks tertentu yang digunakan untuk menghapus catatan data.
	`Attributes() (attrs types.Attributes, err error)`	Meminta atribut antrian. Atribut mencakup jumlah total catatan data dalam antrian dan jumlah catatan data dalam antrian saat ini. Nilai kembali: attrs: atribut antrian. Kunci dan nilai atribut harus berupa tipe STRING.
	`Watch(ctx context.Context, index, window uint64, indexOnly bool, autocommit bool) (watcher types.Watcher, err error)`	Berlangganan catatan data dalam antrian. Kemudian, layanan antrian mendorong data ke klien berdasarkan kondisi tertentu. Parameter: ctx: konteks operasi ini. index: indeks awal catatan data yang dilanggan. window: jumlah maksimum catatan data yang diizinkan untuk didorong ke satu klien oleh layanan antrian. Catatan Jika data tidak dikomit, server tidak akan mendorong data lainnya ke klien. Lalu, jika N catatan data dikomit, N catatan data akan didorong ke server. Ini memastikan bahwa jumlah catatan data yang ditangani oleh klien tidak melebihi nilai yang ditentukan untuk window. Dengan cara ini, konkurensi komputasi di sisi klien dikendalikan. index_only: menentukan apakah hanya mendorong nilai indeks. auto_commit: menentukan apakah akan secara otomatis mengkomit catatan data setelah data tersebut didorong. Kami sarankan Anda mengatur auto_commit ke False. Dalam hal ini, Anda harus secara manual mengkomit catatan data setelah data tersebut diterima dan dihitung. Jika terjadi pengecualian pada instance sebelum perhitungan selesai, catatan data yang belum dikomit akan didorong ke instance lain oleh layanan antrian. Nilai kembali: watcher yang digunakan untuk membaca data yang didorong.
	`Commit(ctx context.Context, indexes ...uint64) error`	Mengkomit catatan data tertentu. Catatan Jika catatan data diproses dan tidak perlu didorong ke instance lain, maka data tersebut dikomit. Setelah itu, catatan data dapat dihapus dari antrian. Parameter: ctx: konteks operasi ini. indexes: nilai indeks tertentu yang sesuai dengan catatan data yang telah dikomit.
types.Watcher	`FrameChan() <-chan types.DataFrame`	Mengembalikan pipeline yang berisi data yang didorong dari server. Pipeline dapat digunakan untuk membaca data secara berulang. Nilai kembali: pipeline yang dapat digunakan untuk membaca data yang didorong.
types.Watcher	`Close()`	Menghentikan watcher untuk menutup koneksi backend. Catatan Hanya satu watcher yang dapat dimulai untuk satu klien. Anda harus menutup watcher sebelum dapat memulai watcher lainnya.

Demo

Input and output as strings

Jika Anda menggunakan prosesor kustom untuk menerapkan model sebagai layanan, string sering digunakan untuk memanggil layanan, seperti layanan yang diterapkan berdasarkan model Predictive Model Markup Language (PMML). Untuk informasi lebih lanjut, lihat demo berikut:

package main

import (
        "fmt"
        "github.com/pai-eas/eas-golang-sdk/eas"
)

func main() {
    client := eas.NewPredictClient("182848887922****.cn-shanghai.pai-eas.aliyuncs.com", "scorecard_pmml_example")
    client.SetToken("YWFlMDYyZDNmNTc3M2I3MzMwYmY0MmYwM2Y2MTYxMTY4NzBkNzdj****")
    client.Init()
    req := "[{\"fea1\": 1, \"fea2\": 2}]"
    for i := 0; i < 100; i++ {
        resp, err := client.StringPredict(req)
        if err != nil {
            fmt.Printf("failed to predict: %v\n", err.Error())
        } else {
            fmt.Printf("%v\n", resp)
        }
    }
}

Input and output as tensors

Jika Anda menggunakan TensorFlow untuk menerapkan model sebagai layanan, Anda harus menggunakan kelas TFRequest dan TFResponse untuk memanggil layanan. Untuk informasi lebih lanjut, lihat demo berikut:

package main

import (
        "fmt"
        "github.com/pai-eas/eas-golang-sdk/eas"
)

func main() {
    client := eas.NewPredictClient("182848887922****.cn-shanghai.pai-eas.aliyuncs.com", "mnist_saved_model_example")
    client.SetToken("YTg2ZjE0ZjM4ZmE3OTc0NzYxZDMyNmYzMTJjZTQ1YmU0N2FjMTAy****")
    client.Init()

    tfreq := eas.TFRequest{}
    tfreq.SetSignatureName("predict_images")
    tfreq.AddFeedFloat32("images", []int64{1, 784}, make([]float32, 784))

    for i := 0; i < 100; i++ {
        resp, err := client.TFPredict(tfreq)
        if err != nil {
            fmt.Printf("failed to predict: %v", err)
        } else {
            fmt.Printf("%v\n", resp)
        }
    }
}

Call a PyTorch model

Jika Anda menggunakan PyTorch untuk menerapkan model sebagai layanan, Anda harus menggunakan kelas TorchRequest dan TorchResponse untuk memanggil layanan. Untuk informasi lebih lanjut, lihat demo berikut:

package main

import (
        "fmt"
        "github.com/pai-eas/eas-golang-sdk/eas"
)

func main() {
    client := eas.NewPredictClient("182848887922****.cn-shanghai.pai-eas.aliyuncs.com", "pytorch_resnet_example")
    client.SetTimeout(500)
    client.SetToken("ZjdjZDg1NWVlMWI2NTU5YzJiMmY5ZmE5OTBmYzZkMjI0YjlmYWVl****")
    client.Init()
    req := eas.TorchRequest{}
    req.AddFeedFloat32(0, []int64{1, 3, 224, 224}, make([]float32, 150528))
    req.AddFetch(0)
    for i := 0; i < 10; i++ {
        resp, err := client.TorchPredict(req)
        if err != nil {
            fmt.Printf("failed to predict: %v", err)
        } else {
            fmt.Println(resp.GetTensorShape(0), resp.GetFloatVal(0))
        }
    }
}

Use a VPC direct connection channel to call a service
Anda dapat menggunakan saluran koneksi langsung VPC untuk mengakses hanya layanan yang diterapkan dalam grup sumber daya khusus untuk EAS. Selain itu, untuk menggunakan saluran tersebut, grup sumber daya khusus untukEAS dan vSwitch yang ditentukan harus terhubung ke VPC. Untuk informasi lebih lanjut, lihat Bekerja dengan grup sumber daya EAS dan Konfigurasi konektivitas jaringan. Dibandingkan dengan mode reguler, mode ini berisi satu baris kode tambahan: client.SetEndpointType(eas.EndpointTypeDirect). Anda dapat menggunakan mode ini dalam skenario konkurensi tinggi dan lalu lintas berat. Untuk informasi lebih lanjut, lihat demo berikut:
```
package main

import (
        "fmt"
        "github.com/pai-eas/eas-golang-sdk/eas"
)

func main() {
    client := eas.NewPredictClient("pai-eas-vpc.cn-shanghai.aliyuncs.com", "scorecard_pmml_example")
    client.SetToken("YWFlMDYyZDNmNTc3M2I3MzMwYmY0MmYwM2Y2MTYxMTY4NzBkNzdj****")
    client.SetEndpointType(eas.EndpointTypeDirect)
    client.Init()
    req := "[{\"fea1\": 1, \"fea2\": 2}]"
    for i := 0; i < 100; i++ {
        resp, err := client.StringPredict(req)
        if err != nil {
            fmt.Printf("failed to predict: %v\n", err.Error())
        } else {
            fmt.Printf("%v\n", resp)
        }
    }
}
```

Set the connection parameters of the client

Anda dapat menetapkan parameter koneksi klien dengan menggunakan atribut http.Transport. Untuk informasi lebih lanjut, lihat demo berikut:

package main

import (
        "fmt"
        "github.com/pai-eas/eas-golang-sdk/eas"
        "net/http"
        "time"
)

func main() {
    client := eas.NewPredictClient("pai-eas-vpc.cn-shanghai.aliyuncs.com", "network_test")
    client.SetToken("MDAwZDQ3NjE3OThhOTI4ODFmMjJiYzE0MDk1NWRkOGI1MmVhMGI0****")
    client.SetEndpointType(eas.EndpointTypeDirect)
    client.SetHttpTransport(&http.Transport{
        MaxConnsPerHost:       300,
        TLSHandshakeTimeout:   100 * time.Millisecond,
        ResponseHeaderTimeout: 200 * time.Millisecond,
        ExpectContinueTimeout: 200 * time.Millisecond,
    })
}

Use the queuing service to send and subscribe to data

Anda dapat mengirim dan meminta data dalam antrian, meminta status antrian, dan berlangganan data yang didorong oleh antrian. Dalam demo berikut, sebuah thread mendorong data ke antrian, dan thread lainnya menggunakan watcher untuk berlangganan data yang didorong. Untuk informasi lebih lanjut, lihat demo berikut:

Catatan

Saat menerapkan layanan inferensi asinkron di EAS, antrian input dan output akan secara otomatis dibuat dalam format berikut:

Antrian input: <domain>/api/predict/<service_name>

Antrian output: <domain>/api/predict/<service_name>/sink

Buat QueueClient menggunakan <service_name> atau <service_name>/sink sesuai dengan kebutuhan Anda.

    const (
        QueueEndpoint = "182848887922****.cn-shanghai.pai-eas.aliyuncs.com"
        // Sebagai contoh: Jika nama layanan EAS adalah test_qservice, maka nama antrian input akan menjadi test_qservice, dan nama antrian output akan menjadi test_qservice/sink.
        QueueName     = "test_qservice"
        QueueToken    = "YmE3NDkyMzdiMzNmMGM3ZmE4ZmNjZDk0M2NiMDA3OTZmNzc1MTUx****"
    )
    queue, err := NewQueueClient(QueueEndpoint, QueueName, QueueToken)

    // potong semua pesan dalam antrian
    attrs, err := queue.Attributes()
    if index, ok := attrs["stream.lastEntry"]; ok {
        idx, _ := strconv.ParseUint(index, 10, 64)
        queue.Truncate(context.Background(), idx+1)
    }

    ctx, cancel := context.WithCancel(context.Background())

    // buat goroutine untuk mengirim pesan ke antrian
    go func() {
        i := 0
        for {
            select {
            case <-time.NewTicker(time.Microsecond * 1).C:
                _, _, err := queue.Put(context.Background(), []byte(strconv.Itoa(i)), types.Tags{})
                if err != nil {
                    fmt.Printf("Error occurred, retry to handle it: %v\n", err)
                }
                i += 1
            case <-ctx.Done():
                break
            }
        }
    }()

    // buat watcher untuk memantau pesan dari antrian
    watcher, err := queue.Watch(context.Background(), 0, 5, false, false)
    if err != nil {
        fmt.Printf("Failed to create a watcher to watch the queue: %v\n", err)
        return
    }

    // baca pesan dari antrian dan komit secara manual
    for i := 0; i < 100; i++ {
        df := <-watcher.FrameChan()
        err := queue.Commit(context.Background(), df.Index.Uint64())
        if err != nil {
            fmt.Printf("Failed to commit index: %v(%v)\n", df.Index, err)
        }
    }

    // semuanya selesai, tutup watcher
    watcher.Close()
    cancel()