Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Kelola Model

Agen Edge Manager dapat memuat beberapa model sekaligus dan membuat kesimpulan dengan model yang dimuat pada perangkat edge. Jumlah model yang dapat dimuat agen ditentukan oleh memori yang tersedia pada perangkat. Agen memvalidasi tanda tangan model dan memuat ke dalam memori semua artefak yang dihasilkan oleh pekerjaan pengemasan tepi. Langkah ini mengharuskan semua sertifikat yang diperlukan yang dijelaskan dalam langkah-langkah sebelumnya untuk diinstal bersama dengan sisa instalasi biner. Jika tanda tangan model tidak dapat divalidasi, maka pemuatan model gagal dengan kode pengembalian dan alasan yang sesuai.

SageMaker Agen Edge Manager menyediakan daftar Manajemen Model APIs yang mengimplementasikan bidang kontrol dan bidang data APIs pada perangkat tepi. Seiring dengan dokumentasi ini, kami sarankan untuk melalui implementasi klien sampel yang menunjukkan penggunaan kanonik dari yang dijelaskan di bawah ini. APIs

protoFile tersedia sebagai bagian dari artefak rilis (di dalam tarball rilis). Dalam dokumen ini, kami mencantumkan dan menjelaskan penggunaan yang APIs tercantum dalam proto file ini.

Ekstrak arsip berdasarkan OS Anda. VERSIONDimana dipecah menjadi tiga komponen:<MAJOR_VERSION>.<YYYY-MM-DD>-<SHA-7>. Lihat Menginstal agen Edge Manager untuk informasi tentang cara mendapatkan versi rilis (<MAJOR_VERSION>), cap waktu artefak rilis (<YYYY-MM-DD>), dan ID komit repositori () SHA-7

Linux

Arsip zip dapat diekstraksi dengan perintah:

tar -xvzf <VERSION>.tgz

Windows

Arsip zip dapat diekstraksi dengan UI atau perintah:

unzip <VERSION>.tgz

Hirarki artefak rilis (setelah mengekstrak tar/zip arsip) ditunjukkan di bawah ini. protoFile agen tersedia di bawahapi/.

0.20201205.7ee4b0b
├── bin
│         ├── sagemaker_edge_agent_binary
│         └── sagemaker_edge_agent_client_example
└── docs
├── api
│         └── agent.proto
├── attributions
│         ├── agent.txt
│         └── core.txt
└── examples
└── ipc_example
├── CMakeLists.txt
├── sagemaker_edge_client.cc
├── sagemaker_edge_client_example.cc
├── sagemaker_edge_client.hh
├── sagemaker_edge.proto
├── README.md
├── shm.cc
├── shm.hh
└── street_small.bmp

Model Beban

Agen Edge Manager mendukung pemuatan beberapa model. API ini memvalidasi tanda tangan model dan memuat ke dalam memori semua artefak yang dihasilkan oleh operasi. EdgePackagingJob Langkah ini mengharuskan semua sertifikat yang diperlukan untuk diinstal bersama dengan instalasi biner agen lainnya. Jika tanda tangan model tidak dapat divalidasi maka langkah ini gagal dengan kode pengembalian yang sesuai dan pesan kesalahan di log.

// perform load for a model
// Note:
// 1. currently only local filesystem paths are supported for loading models.
// 2. multiple models can be loaded at the same time, as limited by available device memory
// 3. users are required to unload any loaded model to load another model.
// Status Codes:
// 1. OK - load is successful
// 2. UNKNOWN - unknown error has occurred
// 3. INTERNAL - an internal error has occurred
// 4. NOT_FOUND - model doesn't exist at the url
// 5. ALREADY_EXISTS - model with the same name is already loaded
// 6. RESOURCE_EXHAUSTED - memory is not available to load the model
// 7. FAILED_PRECONDITION - model is not compiled for the machine.
//
rpc LoadModel(LoadModelRequest) returns (LoadModelResponse);

Input

//
// request for LoadModel rpc call
//
message LoadModelRequest {
  string url = 1;
  string name = 2;  // Model name needs to match regex "^[a-zA-Z0-9](-*[a-zA-Z0-9])*$"
}

Output

//
//
// response for LoadModel rpc call
//
message LoadModelResponse {
  Model model = 1;
}

//
// Model represents the metadata of a model
//  url - url representing the path of the model
//  name - name of model
//  input_tensor_metadatas - TensorMetadata array for the input tensors
//  output_tensor_metadatas - TensorMetadata array for the output tensors
//
// Note:
//  1. input and output tensor metadata could empty for dynamic models.
//
message Model {
  string url = 1;
  string name = 2;
  repeated TensorMetadata input_tensor_metadatas = 3;
  repeated TensorMetadata output_tensor_metadatas = 4;
}

Model Bongkar

Membongkar model yang dimuat sebelumnya. Hal ini diidentifikasi melalui alias model yang disediakan selamaloadModel. Jika alias tidak ditemukan atau model tidak dimuat maka mengembalikan kesalahan.

//
// perform unload for a model
// Status Codes:
// 1. OK - unload is successful
// 2. UNKNOWN - unknown error has occurred
// 3. INTERNAL - an internal error has occurred
// 4. NOT_FOUND - model doesn't exist
//
rpc UnLoadModel(UnLoadModelRequest) returns (UnLoadModelResponse);

Input

//
// request for UnLoadModel rpc call
//
message UnLoadModelRequest {
 string name = 1; // Model name needs to match regex "^[a-zA-Z0-9](-*[a-zA-Z0-9])*$"
}

Output

//
// response for UnLoadModel rpc call
//
message UnLoadModelResponse {}

Daftar Model

Daftar semua model yang dimuat dan aliasnya.

//
// lists the loaded models
// Status Codes:
// 1. OK - unload is successful
// 2. UNKNOWN - unknown error has occurred
// 3. INTERNAL - an internal error has occurred
//
rpc ListModels(ListModelsRequest) returns (ListModelsResponse);

Input

//
// request for ListModels rpc call
//
message ListModelsRequest {}

Output

//
// response for ListModels rpc call
//
message ListModelsResponse {
 repeated Model models = 1;
}

Jelaskan Model

Menjelaskan model yang dimuat pada agen.

//
// Status Codes:
// 1. OK - load is successful
// 2. UNKNOWN - unknown error has occurred
// 3. INTERNAL - an internal error has occurred
// 4. NOT_FOUND - model doesn't exist at the url
//
rpc DescribeModel(DescribeModelRequest) returns (DescribeModelResponse);

Input

//
// request for DescribeModel rpc call
//
message DescribeModelRequest {
  string name = 1;
}

Output

//
// response for DescribeModel rpc call
//
message DescribeModelResponse {
  Model model = 1;
}

Tangkap Data

Memungkinkan aplikasi klien menangkap tensor input dan output di bucket Amazon S3, dan opsional tambahan. Aplikasi klien diharapkan untuk meneruskan ID tangkapan unik bersama dengan setiap panggilan ke API ini. Ini nantinya dapat digunakan untuk menanyakan status tangkapan.

//
// allows users to capture input and output tensors along with auxiliary data.
// Status Codes:
// 1. OK - data capture successfully initiated
// 2. UNKNOWN - unknown error has occurred
// 3. INTERNAL - an internal error has occurred
// 5. ALREADY_EXISTS - capture initiated for the given capture_id
// 6. RESOURCE_EXHAUSTED - buffer is full cannot accept any more requests.
// 7. OUT_OF_RANGE - timestamp is in the future.
// 8. INVALID_ARGUMENT - capture_id is not of expected format.
//
rpc CaptureData(CaptureDataRequest) returns (CaptureDataResponse);

Input

enum Encoding {
 CSV = 0;
 JSON = 1;
 NONE = 2;
 BASE64 = 3;
}

//
// AuxilaryData represents a payload of extra data to be capture along with inputs and outputs of inference
// encoding - supports the encoding of the data
// data - represents the data of shared memory, this could be passed in two ways:
// a. send across the raw bytes of the multi-dimensional tensor array
// b. send a SharedMemoryHandle which contains the posix shared memory segment id and
// offset in bytes to location of multi-dimensional tensor array.
//
message AuxilaryData {
 string name = 1;
 Encoding encoding = 2;
 oneof data {
 bytes byte_data = 3;
 SharedMemoryHandle shared_memory_handle = 4;
 }
}

//
// Tensor represents a tensor, encoded as contiguous multi-dimensional array.
// tensor_metadata - represents metadata of the shared memory segment
// data_or_handle - represents the data of shared memory, this could be passed in two ways:
// a. send across the raw bytes of the multi-dimensional tensor array
// b. send a SharedMemoryHandle which contains the posix shared memory segment
// id and offset in bytes to location of multi-dimensional tensor array.
//
message Tensor {
 TensorMetadata tensor_metadata = 1; //optional in the predict request
 oneof data {
 bytes byte_data = 4;
 // will only be used for input tensors
 SharedMemoryHandle shared_memory_handle = 5;
 }
}

//
// request for CaptureData rpc call
//
message CaptureDataRequest {
 string model_name = 1;
 string capture_id = 2; //uuid string
 Timestamp inference_timestamp = 3;
 repeated Tensor input_tensors = 4;
 repeated Tensor output_tensors = 5;
 repeated AuxilaryData inputs = 6;
 repeated AuxilaryData outputs = 7;
}

Output

//
// response for CaptureData rpc call
//
message CaptureDataResponse {}

Dapatkan Status Capture

Tergantung pada model dimuat input dan output tensor bisa besar (untuk banyak perangkat tepi). Menangkap ke cloud bisa memakan waktu. Jadi CaptureData() diimplementasikan sebagai operasi asinkron. ID tangkapan adalah pengidentifikasi unik yang disediakan klien selama pengambilan panggilan data, ID ini dapat digunakan untuk menanyakan status panggilan asinkron.

//
// allows users to query status of capture data operation
// Status Codes:
// 1. OK - data capture successfully initiated
// 2. UNKNOWN - unknown error has occurred
// 3. INTERNAL - an internal error has occurred
// 4. NOT_FOUND - given capture id doesn't exist.
//
rpc GetCaptureDataStatus(GetCaptureDataStatusRequest) returns (GetCaptureDataStatusResponse);

Input

//
// request for GetCaptureDataStatus rpc call
//
message GetCaptureDataStatusRequest {
  string capture_id = 1;
}

Output

enum CaptureDataStatus {
  FAILURE = 0;
  SUCCESS = 1;
  IN_PROGRESS = 2;
  NOT_FOUND = 3;
}

//
// response for GetCaptureDataStatus rpc call
//
message GetCaptureDataStatusResponse {
  CaptureDataStatus status = 1;
}

Memprediksi

predictAPI melakukan inferensi pada model yang dimuat sebelumnya. Ini menerima permintaan dalam bentuk tensor yang langsung dimasukkan ke dalam jaringan saraf. Outputnya adalah tensor keluaran (atau skalar) dari model. Ini adalah panggilan blokir.

//
// perform inference on a model.
//
// Note:
// 1. users can chose to send the tensor data in the protobuf message or
// through a shared memory segment on a per tensor basis, the Predict
// method with handle the decode transparently.
// 2. serializing large tensors into the protobuf message can be quite expensive,
// based on our measurements it is recommended to use shared memory of
// tenors larger than 256KB.
// 3. SMEdge IPC server will not use shared memory for returning output tensors,
// i.e., the output tensor data will always send in byte form encoded
// in the tensors of PredictResponse.
// 4. currently SMEdge IPC server cannot handle concurrent predict calls, all
// these call will be serialized under the hood. this shall be addressed
// in a later release.
// Status Codes:
// 1. OK - prediction is successful
// 2. UNKNOWN - unknown error has occurred
// 3. INTERNAL - an internal error has occurred
// 4. NOT_FOUND - when model not found
// 5. INVALID_ARGUMENT - when tenors types mismatch
//
rpc Predict(PredictRequest) returns (PredictResponse);

Input

// request for Predict rpc call
//
message PredictRequest {
string name = 1;
repeated Tensor tensors = 2;
}

//
// Tensor represents a tensor, encoded as contiguous multi-dimensional array.
//    tensor_metadata - represents metadata of the shared memory segment
//    data_or_handle - represents the data of shared memory, this could be passed in two ways:
//                        a. send across the raw bytes of the multi-dimensional tensor array
//                        b. send a SharedMemoryHandle which contains the posix shared memory segment
//                            id and offset in bytes to location of multi-dimensional tensor array.
//
message Tensor {
  TensorMetadata tensor_metadata = 1; //optional in the predict request
  oneof data {
    bytes byte_data = 4;
    // will only be used for input tensors
    SharedMemoryHandle shared_memory_handle = 5;
  }
}

//
// Tensor represents a tensor, encoded as contiguous multi-dimensional array.
//    tensor_metadata - represents metadata of the shared memory segment
//    data_or_handle - represents the data of shared memory, this could be passed in two ways:
//                        a. send across the raw bytes of the multi-dimensional tensor array
//                        b. send a SharedMemoryHandle which contains the posix shared memory segment
//                            id and offset in bytes to location of multi-dimensional tensor array.
//
message Tensor {
  TensorMetadata tensor_metadata = 1; //optional in the predict request
  oneof data {
    bytes byte_data = 4;
    // will only be used for input tensors
    SharedMemoryHandle shared_memory_handle = 5;
  }
}

//
// TensorMetadata represents the metadata for a tensor
//    name - name of the tensor
//    data_type  - data type of the tensor
//    shape - array of dimensions of the tensor
//
message TensorMetadata {
  string name = 1;
  DataType data_type = 2;
  repeated int32 shape = 3;
}

//
// SharedMemoryHandle represents a posix shared memory segment
//    offset - offset in bytes from the start of the shared memory segment.
//    segment_id - shared memory segment id corresponding to the posix shared memory segment.
//    size - size in bytes of shared memory segment to use from the offset position.
//
message SharedMemoryHandle {
  uint64 size = 1;
  uint64 offset = 2;
  uint64 segment_id = 3;
}

Output

catatan

PredictResponseSatu-satunya yang kembali Tensors dan tidakSharedMemoryHandle.

// response for Predict rpc call
//
message PredictResponse {
   repeated Tensor tensors = 1;
}