Formatos de dados comuns para inferência

Os algoritmos do Amazon SageMaker AI aceitam e produzem vários tipos de MIME diferentes para as cargas úteis de HTTP usadas na recuperação de predições de minilote e on-line. Você pode usar diversos serviços da AWS para transformar ou pré-processar registros antes de executar a inferência. No mínimo, é preciso converter os dados para os seguintes itens:

Converter dados para serialização de solicitação de inferência

As opções de tipo de conteúdo para as solicitações de inferência de algoritmo do Amazon SageMaker AI incluem: text/csv, application/json e application/x-recordio-protobuf. Algoritmos que não oferecem apoio a todos esses tipos podem oferecer compatibilidade com outros tipos. O XGBoost, por exemplo, só oferece apoio a text/csv nessa lista, mas também oferece apoio a text/libsvm.

Para text/csv, o valor do argumento do corpo para invoke_endpoint deve ser uma string com vírgulas que separem os valores para cada atributo. Por exemplo, um registro para um modelo com quatro atributos pode parecer assim: 1.5,16.0,14,23.0. Todas as transformações executadas nos dados de treinamento também devem ser executadas nos dados antes da obtenção da inferência. A ordem dos atributos é importante, devendo permanecer inalterada.

application/json é significativamente mais flexível e fornece vários formatos possíveis para os desenvolvedores usarem em suas aplicações. Basicamente, em JavaScript, a carga útil pode parecer com o seguinte:

let request = {
  // Instances might contain multiple rows that predictions are sought for.
  "instances": [
    {
      // Request and algorithm specific inference parameters.
      "configuration": {},
      // Data in the specific format required by the algorithm.
      "data": {
         "<field name>": dataElement
       }
    }
  ]
}

Para especificar o dataElement, você tem as seguintes opções:

Buffers de protocolo equivalentes

// Has the same format as the protocol buffers implementation described for training.
let dataElement = {
  "keys": [],
  "values": [],
  "shape": []
}

Vetor numérico simples

// An array containing numeric values is treated as an instance containing a
// single dense vector.
let dataElement = [1.5, 16.0, 14.0, 23.0]

// It will be converted to the following representation by the SDK.
let converted = {
  "features": {
    "values": dataElement
  }
}

Para vários registros

let request = {
  "instances": [
    // First instance.
    {
      "features": [ 1.5, 16.0, 14.0, 23.0 ]
    },
    // Second instance.
    {
      "features": [ -2.0, 100.2, 15.2, 9.2 ]
    }
  ]
}

Converter dados para desserialização de respostas de inferência

Os algoritmos do Amazon SageMaker AI retornam JSON em vários layouts. Basicamente, a estrutura é esta:

let response = {
  "predictions": [{
    // Fields in the response object are defined on a per algorithm-basis.
  }]
}

Os campos incluídos nas predições diferem de algoritmo para algoritmo. Veja a seguir exemplos de resultado para o algoritmo k-means.

Inferência de único registro

let response = {
  "predictions": [{
    "closest_cluster": 5,
    "distance_to_cluster": 36.5
  }]
}

Inferência de vários registros

let response = {
  "predictions": [
    // First instance prediction.
    {
      "closest_cluster": 5,
      "distance_to_cluster": 36.5
    },
    // Second instance prediction.
    {
      "closest_cluster": 2,
      "distance_to_cluster": 90.3
    }
  ]
}

Inferência de vários registros com entrada protobuf

{
  "features": [],
  "label": {
    "closest_cluster": {
      "values": [ 5.0 ] // e.g. the closest centroid/cluster was 1.0
    },
    "distance_to_cluster": {
      "values": [ 36.5 ]
    }
  },
  "uid": "abc123",
  "metadata": "{ "created_at": '2017-06-03' }"
}

Os algoritmos do SageMaker AI também aceitam o formato JSONLINES, em que o conteúdo da resposta por registro é o mesmo que no formato JSON. A estrutura de vários registros é uma coleção de objetos de resposta por registro separados por caracteres de nova linha. O conteúdo da resposta do algoritmo KMeans interno para 2 pontos de dados de entrada é:

{"distance_to_cluster": 23.40593910217285, "closest_cluster": 0.0}
{"distance_to_cluster": 27.250282287597656, "closest_cluster": 0.0}

Ao executar uma transformação em lote, recomendamos usar o tipo de resposta jsonlines, definindo o campo Accept em CreateTransformJobRequest como application/jsonlines.

Formatos de solicitação comuns para todos os algoritmos

A maioria dos algoritmos usa vários dos formatos de solicitação de inferência a seguir:

Formato da solicitação JSON

Tipo de conteúdo: application/JSON

Formato denso

let request =   {
    "instances":    [
        {
            "features": [1.5, 16.0, 14.0, 23.0]
        }
    ]
}


let request =   {
    "instances":    [
        {
            "data": {
                "features": {
                    "values": [ 1.5, 16.0, 14.0, 23.0]
                }
            }
        }
    ]
}

Formato esparso

{
	"instances": [
		{"data": {"features": {
					"keys": [26, 182, 232, 243, 431],
					"shape": [2000],
					"values": [1, 1, 1, 4, 1]
				}
			}
		},
		{"data": {"features": {
					"keys": [0, 182, 232, 243, 431],
					"shape": [2000],
					"values": [13, 1, 1, 4, 1]
				}
			}
		},
	]
}

Formato da solicitação JSONLINES

Tipo de conteúdo: application/JSONLINES

Formato denso

Um único registro no formato denso pode ser representado como:

{ "features": [1.5, 16.0, 14.0, 23.0] }

ou:

{ "data": { "features": { "values": [ 1.5, 16.0, 14.0, 23.0] } }

Formato esparso

Um único registro no formato esparso é representado como:

{"data": {"features": { "keys": [26, 182, 232, 243, 431], "shape": [2000], "values": [1, 1, 1, 4, 1] } } }

Vários registros são representados como uma coleção das representações de registro único, separadas por caracteres de nova linha:

{"data": {"features": { "keys": [0, 1, 3], "shape": [4], "values": [1, 4, 1] } } }
{ "data": { "features": { "values": [ 1.5, 16.0, 14.0, 23.0] } }
{ "features": [1.5, 16.0, 14.0, 23.0] }

Formato da solicitação CSV

Tipo de conteúdo: text/csv;label_size=0

Formato da solicitação RECORDIO

Tipo de conteúdo: application/x-recordio-protobuf

Use a transformação em lote com algoritmos integrados

Ao executar a transformação em lote, recomendamos usar o tipo de resposta JSONLINES em vez do JSON, se aceito pelo algoritmo. Para fazer isso, defina o campo Accept em CreateTransformJobRequest a application/jsonlines.

Quando você cria um trabalho de transformação, SplitType deve ser definido de acordo com ContentType dos dados de entrada. De modo semelhante, dependendo do campo Accept em CreateTransformJobRequest, AssembleWith deve ser ajustado de acordo. Use a seguinte tabela para definir esses campos:

Para obter mais informações sobre formatos de resposta de algoritmos específicos, consulte os seguintes tópicos: