Este guia explica as APIs do SDK for Go oficial e fornece exemplos completos de código para formatos comuns de entrada e saída.
Para obter informações sobre casos de uso e princípios de invocação do SDK, consulte SDKs de invocação de serviço.
Pré-requisitos
Ao chamar um serviço de inferência com o SDK for Go, o gerenciador de pacotes Go baixa automaticamente o código-fonte do SDK do GitHub durante a compilação. Não é necessário instalar o SDK previamente. Para personalizar a lógica de invocação, baixe o código-fonte do SDK for Go e modifique-o localmente.
Para importar o SDK, use o seguinte código:
import (
"github.com/pai-eas/eas-golang-sdk/eas"
)Início rápido
Selecione a classe Request correspondente ao formato dos dados de entrada do modelo. O exemplo a seguir demonstra uma invocação mínima e de ponta a ponta usando uma requisição do tipo string.
package main
import (
"fmt"
"github.com/pai-eas/eas-golang-sdk/eas"
)
func main() {
client := eas.NewPredictClient("182848887922****.cn-shanghai.pai-eas.aliyuncs.com", "my_service")
client.SetToken("YOUR_SERVICE_TOKEN")
client.Init()
resp, err := client.StringPredict("[{}]")
if err != nil {
fmt.Printf("failed to predict: %v\n", err.Error())
} else {
fmt.Printf("%v\n", resp)
}
}Referência da API
O SDK for Go oferece as classes abaixo, organizadas por finalidade:
Grupo | Descrição |
Cliente principal | PredictClient: Configura informações do serviço, como endpoint, nome do serviço e token, além de enviar requisições e receber respostas. |
Entrada e saída |
|
Serviço de fila |
|
PredictClient
Classe principal do cliente usada para configurar informações do serviço, enviar requisições e receber resultados de previsão.
Método | Descrição |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| Inicializa o objeto PredictClient. Após definir os parâmetros com os métodos anteriores, chame |
|
|
|
|
|
|
|
|
TFRequest
Constrói dados de entrada para modelos TensorFlow.
Método | Descrição |
|
|
|
|
|
|
TFResponse
Analisa dados de saída de modelos TensorFlow.
Método | Descrição |
|
|
|
TorchRequest
Constrói dados de entrada para modelos PyTorch.
Método | Descrição |
| Cria um objeto |
|
|
|
|
TorchResponse
Analisa dados de saída de modelos PyTorch.
Método | Descrição |
|
|
|
QueueClient
Interage com o serviço de fila do EAS para produzir, consumir e gerenciar dados.
Método | Descrição |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
types.Watcher
Lê dados enviados via push do canal de inscrição do serviço de fila.
Método | Descrição |
|
|
| Fecha um objeto watcher e sua conexão de dados de backend. Nota Um cliente pode ter apenas um objeto watcher ativo por vez. Feche o objeto watcher atual antes de criar um novo. |
Exemplos
Inferência síncrona por formato
Escolha o exemplo de código com base nos tipos de entrada e saída do seu serviço.
String
Se você implantar um serviço com um processador personalizado, geralmente o invocará usando strings, por exemplo, ao chamar um serviço de modelo PMML. O programa a seguir mostra um exemplo completo.
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)
}
}
}TensorFlow
Para modelos TensorFlow, use TFRequest e TFResponse como formatos de dados de entrada e saída, respectivamente. O programa a seguir mostra um exemplo completo.
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)
}
}
}PyTorch
Para modelos PyTorch, use TorchRequest e TorchResponse como formatos de dados de entrada e saída, respectivamente. O programa a seguir mostra um exemplo completo.
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))
}
}
}Conexão direta VPC
Uma conexão direta VPC permite acessar serviços implantados em um grupo de recursos dedicado do Elastic Algorithm Service (EAS). Conecte também o grupo de recursos ao vSwitch especificado antes de usar este modo. Para obter informações sobre como adquirir um grupo de recursos dedicado do EAS e configurar a conectividade de rede, consulte Usar grupos de recursos do EAS e Configurar o EAS para acessar recursos públicos ou internos. Este método difere de uma invocação padrão por exigir apenas uma linha adicional de código: client.SetEndpointType(eas.EndpointTypeDirect). Este modo é ideal para serviços de alto tráfego e alta concorrência. Veja abaixo um exemplo de código:
package main
import (
"fmt"
"github.com/pai-eas/eas-golang-sdk/eas"
)
func main() {
// Format of a VPC direct connection endpoint: {uid}.vpc.{region-id}.pai-eas.aliyuncs.com. You can find the endpoint on the Invocation Information tab of the service details page in the EAS console.
client := eas.NewPredictClient("182848887922****.vpc.cn-shanghai.pai-eas.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)
}
}
}Parâmetros de conexão do cliente
Defina os parâmetros de conexão do cliente usando a propriedade http.Transport. O exemplo a seguir demonstra como configurar essas definições:
package main
import (
"fmt"
"github.com/pai-eas/eas-golang-sdk/eas"
"net/http"
"time"
)
func main() {
// Format of a VPC direct connection endpoint: {uid}.vpc.{region-id}.pai-eas.aliyuncs.com. You can find the endpoint on the Invocation Information tab of the service details page in the EAS console.
client := eas.NewPredictClient("182848887922****.vpc.cn-shanghai.pai-eas.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,
})
}Serviço de fila
Use o QueueClient para enviar dados a um serviço de fila, consultar dados, verificar o status do serviço de fila e inscrever-se em notificações push de dados do serviço. Neste exemplo, uma goroutine envia dados para o serviço de fila, enquanto outra usa um watcher para se inscrever e receber esses dados.
Ao implantar um serviço de inferência assíncrona no EAS, uma fila de entrada e uma fila de saída são geradas automaticamente. Os endereços geralmente seguem os formatos abaixo:
Fila de entrada: <domain>/api/predict/<service_name>
Fila de saída: <domain>/api/predict/<service_name>/sink
Use <service_name> ou <service_name>/sink para construir o QueueClient conforme suas necessidades.
const (
QueueEndpoint = "182848887922****.cn-shanghai.pai-eas.aliyuncs.com"
// For example, if the EAS service name is test_qservice, the input queue name is test_qservice, and the output queue name is test_qservice/sink.
QueueName = "test_qservice"
QueueToken = "YmE3NDkyMzdiMzNmMGM3ZmE4ZmNjZDk0M2NiMDA3OTZmNzc1MTUx****"
)
queue, err := NewQueueClient(QueueEndpoint, QueueName, QueueToken)
// truncate all messages in the queue
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())
// create a goroutine to send messages to the queue
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 occured, retry to handle it: %v\n", err)
}
i += 1
case <-ctx.Done():
break
}
}
}()
// create a watcher to watch the messages from the queue
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
}
// read messages from the queue and commit manually
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)
}
}
// everything is done, close the watcher
watcher.Close()
cancel()Solução de problemas
Para solucionar problemas comuns ao chamar serviços com o SDK for Go, incluindo causas e soluções, consulte a seção "Solucionar exceções de invocação" em SDKs de invocação de serviço.
Para obter uma lista completa de códigos de status de serviço, mensagens de erro e ações recomendadas, consulte Apêndice: Códigos de status de serviço e erros comuns.