Platform For AI：Latih dan terapkan model PyTorch

Instal dan konfigurasikan SDK

Jalankan perintah berikut di CLI untuk menginstal PAI SDK untuk Python:

python -m pip install "alipai>=0.4.0"

Jalankan perintah berikut di CLI untuk mengonfigurasi PAI SDK untuk Python:

python -m pai.toolkit.config

Untuk informasi lebih lanjut, lihat Instal dan Konfigurasikan PAI SDK untuk Python.

Persiapkan data pelatihan

Dalam contoh ini, dataset MNIST digunakan untuk melatih model klasifikasi gambar. Untuk mengirimkan pekerjaan pelatihan di PAI, Anda perlu menyiapkan dan mengunggah dataset ke Bucket OSS.

1. Unduh Dataset MNIST

   Jalankan skrip Shell berikut untuk mengunduh dataset MNIST ke direktori lokal bernama data.

   #!/bin/sh
   set -e
   
   url_prefix="https://ossci-datasets.s3.amazonaws.com/mnist/"
   # Anda dapat menggunakan alamat berikut jika unduhan memakan waktu terlalu lama.
   # url_prefix="http://yann.lecun.com/exdb/mnist/"
   
   mkdir -p data/MNIST/raw/
   
   wget -nv ${url_prefix}train-images-idx3-ubyte.gz -P data/MNIST/raw/
   wget -nv ${url_prefix}train-labels-idx1-ubyte.gz -P data/MNIST/raw/
   wget -nv ${url_prefix}t10k-images-idx3-ubyte.gz -P data/MNIST/raw/
   wget -nv ${url_prefix}t10k-labels-idx1-ubyte.gz -P data/MNIST/raw/
   

2. Unggah Dataset ke Bucket OSS

   Anda dapat menggunakan alat CLI ossutil yang disediakan oleh OSS untuk mengunggah data. Untuk informasi tentang cara menginstal dan menggunakan ossutil, lihat ossutil 1.0. Anda juga dapat menggunakan metode yang disediakan oleh PAI SDK untuk Python untuk mengunggah data pelatihan ke jalur /mnist/data/ di Bucket OSS.

   • Gunakan ossutil:

     ossutil cp -rf ./data oss://<YourOssBucket>/mnist/data/

   • Gunakan PAI SDK untuk Python:

     from pai.common.oss_utils import upload
     from pai.session import get_default_session
     
     sess = get_default_session()
     data_uri = upload("./data/", oss_path="mnist/data/", bucket=sess.oss_bucket)
     print(data_uri)
     

Persiapkan skrip pelatihan

Anda perlu menulis skrip pelatihan menggunakan PyTorch sebelum mengirimkan pekerjaan pelatihan. Skrip pelatihan yang digunakan dalam contoh ini dimodifikasi berdasarkan contoh MNIST yang disediakan oleh PyTorch. Modifikasi termasuk mengubah logika pemuatan data dan penyimpanan model.

• Peroleh Jalur Data Input Menggunakan Variabel Lingkungan

  Gunakan estimator.fit(inputs={"train_data":data_uri}) untuk memasang data yang disimpan di OSS ke wadah pelatihan. Skrip pelatihan dapat memperoleh data yang dipasang dengan membaca file lokal.

  inputs dari metode estimator.fit bertipe DICT. Setiap input adalah saluran, di mana kunci adalah nama saluran, dan nilainya adalah jalur data yang disimpan. Skrip pelatihan dapat memperoleh jalur data yang dipasang di wadah kerja dengan variabel PAI_INPUT_{ChannelNameUpperCase}.

  Ubah kode pemuatan data berdasarkan konten berikut:

  - dataset1 = datasets.MNIST("../data", train=True, download=True, transform=transform)
  - dataset2 = datasets.MNIST("../data", train=False, transform=transform)
  
  + # Peroleh jalur data input menggunakan variabel lingkungan.
  + data_path = os.environ.get("PAI_INPUT_TRAIN_DATA", "../data")
  + dataset1 = datasets.MNIST(data_path, train=True, download=True, transform=transform)
  + dataset2 = datasets.MNIST(data_path, train=False, transform=transform)
  

• Peroleh Jalur Model Keluaran Menggunakan Variabel Lingkungan

  Anda perlu menyimpan model ke jalur tertentu yang ditentukan oleh variabel PAI_OUTPUT_MODEL di lingkungan pelatihan. Jalur defaultnya adalah /ml/output/model. Data dan model di jalur tersebut disimpan ke Bucket OSS Anda.

  Ubah kode keluaran model berdasarkan konten berikut:

  - if args.save_model:
  -     torch.save(model.state_dict(), "mnist_cnn.pt")
  + # Simpan model.
  + save_model(model)
  + 
  + def save_model(model):
  +     """Konversi model ke TorchScript dan simpan ke jalur yang ditentukan."""
  +     output_model_path = os.environ.get("PAI_OUTPUT_MODEL")
  +     os.makedirs(output_model_path, exist_ok=True)
  +     
  +     m = torch.jit.script(model)
  +     m.save(os.path.join(output_model_path, "mnist_cnn.pt"))
  

Saat menggunakan prosesor PyTorch bawaan yang disediakan oleh PAI untuk membuat layanan, model input harus dalam format TorchScript. Dalam contoh ini, model diekspor dalam format TorchScript. Contoh skrip pelatihan:

# source: https://github.com/pytorch/examples/blob/main/mnist/main.py
from __future__ import print_function

import argparse
import os

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.optim.lr_scheduler import StepLR
from torchvision import datasets, transforms


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, 3, 1)
        self.conv2 = nn.Conv2d(32, 64, 3, 1)
        self.dropout1 = nn.Dropout(0.25)
        self.dropout2 = nn.Dropout(0.5)
        self.fc1 = nn.Linear(9216, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = F.relu(x)
        x = self.conv2(x)
        x = F.relu(x)
        x = F.max_pool2d(x, 2)
        x = self.dropout1(x)
        x = torch.flatten(x, 1)
        x = self.fc1(x)
        x = F.relu(x)
        x = self.dropout2(x)
        x = self.fc2(x)
        output = F.log_softmax(x, dim=1)
        return output


def train(args, model, device, train_loader, optimizer, epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = F.nll_loss(output, target)
        loss.backward()
        optimizer.step()
        if batch_idx % args.log_interval == 0:
            print(
                "Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}".format(
                    epoch,
                    batch_idx * len(data),
                    len(train_loader.dataset),
                    100.0 * batch_idx / len(train_loader),
                    loss.item(),
                )
            )
            if args.dry_run:
                break


def test(model, device, test_loader):
    model.eval()
    test_loss = 0
    correct = 0
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            test_loss += F.nll_loss(
                output, target, reduction="sum"
            ).item()  # jumlahkan loss batch
            pred = output.argmax(
                dim=1, keepdim=True
            )  # dapatkan indeks probabilitas log maksimum
            correct += pred.eq(target.view_as(pred)).sum().item()

    test_loss /= len(test_loader.dataset)

    print(
        "\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n".format(
            test_loss,
            correct,
            len(test_loader.dataset),
            100.0 * correct / len(test_loader.dataset),
        )
    )


def main():
    # Pengaturan pelatihan
    parser = argparse.ArgumentParser(description="PyTorch MNIST Example")
    parser.add_argument(
        "--batch-size",
        type=int,
        default=64,
        metavar="N",
        help="input batch size for training (default: 64)",
    )
    parser.add_argument(
        "--test-batch-size",
        type=int,
        default=1000,
        metavar="N",
        help="input batch size for testing (default: 1000)",
    )
    parser.add_argument(
        "--epochs",
        type=int,
        default=14,
        metavar="N",
        help="number of epochs to train (default: 14)",
    )
    parser.add_argument(
        "--lr",
        type=float,
        default=1.0,
        metavar="LR",
        help="learning rate (default: 1.0)",
    )
    parser.add_argument(
        "--gamma",
        type=float,
        default=0.7,
        metavar="M",
        help="Learning rate step gamma (default: 0.7)",
    )
    parser.add_argument(
        "--no-cuda", action="store_true", default=False, help="disables CUDA training"
    )
    parser.add_argument(
        "--dry-run",
        action="store_true",
        default=False,
        help="quickly check a single pass",
    )
    parser.add_argument(
        "--seed", type=int, default=1, metavar="S", help="random seed (default: 1)"
    )
    parser.add_argument(
        "--log-interval",
        type=int,
        default=10,
        metavar="N",
        help="how many batches to wait before logging training status",
    )
    parser.add_argument(
        "--save-model",
        action="store_true",
        default=False,
        help="For Saving the current Model",
    )
    args = parser.parse_args()
    use_cuda = not args.no_cuda and torch.cuda.is_available()

    torch.manual_seed(args.seed)

    device = torch.device("cuda" if use_cuda else "cpu")

    train_kwargs = {"batch_size": args.batch_size}
    test_kwargs = {"batch_size": args.test_batch_size}
    if use_cuda:
        cuda_kwargs = {"num_workers": 1, "pin_memory": True, "shuffle": True}
        train_kwargs.update(cuda_kwargs)
        test_kwargs.update(cuda_kwargs)

    transform = transforms.Compose(
        [transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))]
    )

    data_path = os.environ.get("PAI_INPUT_DATA")
    dataset1 = datasets.MNIST(data_path, train=True, download=True, transform=transform)
    dataset2 = datasets.MNIST(data_path, train=False, transform=transform)
    train_loader = torch.utils.data.DataLoader(dataset1, **train_kwargs)
    test_loader = torch.utils.data.DataLoader(dataset2, **test_kwargs)

    model = Net().to(device)
    optimizer = optim.Adadelta(model.parameters(), lr=args.lr)

    scheduler = StepLR(optimizer, step_size=1, gamma=args.gamma)
    for epoch in range(1, args.epochs + 1):
        train(args, model, device, train_loader, optimizer, epoch)
        test(model, device, test_loader)
        scheduler.step()

    # Simpan model.
    save_model(model)


def save_model(model):
    """Konversi model ke TorchScript dan simpan ke jalur yang ditentukan."""
    output_model_path = os.environ.get("PAI_OUTPUT_MODEL")
    os.makedirs(output_model_path, exist_ok=True)

    m = torch.jit.script(model)
    m.save(os.path.join(output_model_path, "mnist_cnn.pt"))


if __name__ == "__main__":
    main()

Simpan kode pelatihan di atas ke direktori lokal dan gunakan Estimator untuk mengirimkannya ke PAI. Dalam contoh ini, direktori baru bernama train_src dibuat dan skrip pelatihan disimpan ke train_src/train.py.

|-- train_src # Direktori skrip pelatihan yang akan diunggah.
    |-- requirements.txt # Opsional. Ketergantungan pihak ketiga dari pekerjaan pelatihan.
    '-- train.py # Skrip pelatihan yang disimpan 

Kirim pekerjaan pelatihan

Estimator memungkinkan Anda menggunakan skrip pelatihan lokal dan citra untuk menjalankan pekerjaan pelatihan di PAI.

• Skrip dan Perintah Pekerjaan Pelatihan

  Direktori skrip pelatihan, yang ditentukan oleh parameter source_dir, diunggah ke OSS dan disiapkan di wadah pekerjaan sebelum pekerjaan dimulai. Direktori defaultnya adalah /ml/usercode. Direktori kerja perintah startup, yang ditentukan oleh parameter command, juga /ml/usercode.

• Citra Pekerjaan Pelatihan

  Dalam contoh ini, citra PyTorch yang disediakan oleh PAI digunakan untuk menjalankan pekerjaan pelatihan.

• Hyperparameter Pekerjaan Pelatihan

  Anda dapat memperoleh hyperparameter pekerjaan pelatihan dengan membaca file ${PAI_CONFIG_DIR}/hyperparameters.json atau dengan menggunakan variabel lingkungan. Untuk informasi lebih lanjut, lihat Variabel Lingkungan Preset Pekerjaan Pelatihan.

  Dalam contoh ini, perintah yang dieksekusi adalah python train.py $PAI_USER_ARGS, di mana variabel PAI_USER_ARGS adalah string yang diperoleh dari hyperparameter. Perintah startup akhir untuk pekerjaan pelatihan adalah python train.py --epochs 5 --batch-size 256 --lr 0.5.

• Tentukan Metrik Pelatihan Menggunakan metric_definitions

  PAI memungkinkan Anda memperoleh metrik pelatihan dengan mencocokkan ekspresi reguler dari log pelatihan keluaran yang berisi standar keluaran dan standar kesalahan. Sistem juga mencetak tautan ke halaman detail. Anda dapat melihat konfigurasi detail, log keluaran, dan metrik pekerjaan pelatihan di halaman detail.

• Tentukan Jenis Instans untuk Pekerjaan Pelatihan Menggunakan instance_type

  Untuk informasi lebih lanjut tentang jenis instans yang didukung oleh pekerjaan pelatihan di PAI, lihat Lampiran: Detail Harga Grup Sumber Daya Publik.

Contoh Kode Estimator:

from pai.estimator import Estimator
from pai.image import retrieve

# Gunakan citra PyTorch 1.18 untuk pelatihan berbasis GPU untuk menjalankan skrip pelatihan.
image_uri = retrieve(
    "PyTorch", framework_version="1.8PAI", accelerator_type="GPU"
).image_uri
print(image_uri)

est = Estimator(
    # Perintah startup pekerjaan pelatihan. Direktori kerja defaultnya adalah /ml/usercode/.
    command="python train.py $PAI_USER_ARGS",
    # Jalur relatif atau absolut dari direktori kode pelatihan yang akan diunggah.
  	# Secara default, direktori /ml/usercode dari lingkungan pelatihan digunakan.
    source_dir="./train_src/",
    # Citra pekerjaan pelatihan.
    image_uri=image_uri,
    # Konfigurasi instans.
    instance_type="ecs.gn6i-c4g1.xlarge",  # 4vCPU 15GB 1*NVIDIA T4
    # Hyperparameter pekerjaan pelatihan.
    hyperparameters={
        "epochs": 5,
        "batch-size": 64 * 4,
        "lr": 0.5,
    },
    # Konfigurasi metrik pekerjaan pelatihan.
    metric_definitions=[
        {
            "Name": "loss",
            "Regex": r".*loss=([-+]?[0-9]*.?[0-9]+(?:[eE][-+]?[0-9]+)?).*",
        },
    ],
    base_job_name="pytorch_mnist",
)

Gunakan data pelatihan yang diunggah ke OSS sebagai data input dan jalankan pekerjaan pelatihan.

# Jika Anda menggunakan ossutil untuk mengunggah data pelatihan, Anda perlu secara eksplisit menentukan OSS URI dari data input.
# data_uri = "oss://<YourOssBucket>/mnist/data/"

# Kirim pekerjaan pelatihan.
est.fit(
    inputs={
        "train_data": data_uri,
    }
)

# Jalur keluaran model yang telah dilatih.
print("Output model data Pekerjaan Pelatihan:")
print(est.model_data())

Anda dapat menggunakan metode est.fit untuk mengirimkan pekerjaan pelatihan Anda ke PAI untuk dijalankan. Setelah pekerjaan pelatihan dikirimkan, SDK mencetak tautan halaman detail pekerjaan dan log pekerjaan pelatihan hingga pekerjaan selesai dijalankan.

Jika Anda perlu menggunakan data di OSS, gunakan parameter inputs untuk meneruskan data menggunakan metode estimator.fit. Jika Anda menggunakan parameter inputs untuk meneruskan data, jalur penyimpanan data dilampirkan ke direktori kerja. Skrip pelatihan Anda dapat memuat data dengan membaca file lokal.

Untuk informasi lebih lanjut tentang mengirimkan pekerjaan pelatihan, lihat Kirim Pekerjaan Pelatihan.

Terapkan layanan inferensi

Setelah pekerjaan pelatihan selesai, Anda dapat menggunakan metode estimator.model_data() untuk memperoleh jalur OSS dari model yang dihasilkan oleh pekerjaan pelatihan. Bagian berikut menjelaskan cara menerapkan model yang telah dilatih ke PAI sebagai layanan inferensi online.

• Gunakan InferenceSpec untuk menjelaskan cara menggunakan model untuk membangun layanan inferensi.

  Anda dapat menggunakan prosesor atau citra kustom untuk menerapkan model. Kedua metode dijelaskan dalam contoh berikut.

• Gunakan metode Model.deploy untuk mengonfigurasi informasi seperti sumber daya yang digunakan oleh layanan dan nama layanan, serta membuat layanan inferensi.

Untuk informasi lebih lanjut, lihat Terapkan Layanan Inferensi.

Terapkan layanan model menggunakan prosesor

Prosesor berisi deskripsi abstrak dari paket inferensi. Ini digunakan untuk memuat model dan memulai layanan inferensi model. Layanan inferensi model menyediakan API untuk pengguna untuk memanggil. PAI menyediakan prosesor PyTorch bawaan yang memungkinkan Anda menerapkan model dalam format TorchScript ke PAI dan membuat layanan inferensi.

1. Terapkan Layanan

   Dalam contoh berikut, prosesor PyTorch digunakan untuk menerapkan model yang telah dilatih sebagai layanan inferensi. Contoh kode:

   from pai.model import Model, InferenceSpec
   from pai.predictor import Predictor
   from pai.common.utils import random_str
   
   
   m = Model(
    model_data=est.model_data(),
    # Gunakan prosesor PyTorch yang disediakan oleh PAI.
    inference_spec=InferenceSpec(processor="pytorch_cpu_1.10"),
   )
   
   p: Predictor = m.deploy(
    service_name="tutorial_pt_mnist_proc_{}".format(random_str(6)),
    instance_type="ecs.c6.xlarge",
   )
   
   print(p.service_name)
   print(p.service_status)
   

   Model.deploy membuat layanan inferensi baru dan mengembalikan objek Predictor. Anda dapat menggunakan metode Predictor.predict untuk mengirim permintaan ke layanan inferensi dan memperoleh hasil prediksi.

2. Jalankan Layanan Inferensi

   Dalam contoh ini, sampel uji dibuat menggunakan numpy dan dikirim ke layanan inferensi.

   import numpy as np
   
   # Input bertipe Float32 dan dalam format (BatchSize, Channel, Weight, Height).
   dummy_input = np.random.rand(2, 1, 28, 28).astype(np.float32)
   
   # np.random.rand(1, 1, 28, 28).dtype
   res = p.predict(dummy_input)
   print(res)
   
   print(np.argmax(res, 1))
   

3. Anda dapat menghapus layanan inferensi menggunakan Predictor.delete_service setelah proses prediksi selesai.

   Anda dapat menghapus layanan inferensi menggunakan Predictor.delete_service setelah prediksi selesai.

   p.delete_service()

Terapkan model menggunakan citra

Dalam skenario yang sensitif terhadap performa, Anda dapat menerapkan model menggunakan prosesor. Dalam skenario yang memiliki persyaratan kustom, seperti ketika model memiliki dependensi pihak ketiga, atau ketika layanan inferensi memerlukan pra-pemrosesan dan pasca-pemrosesan, Anda dapat menerapkan model menggunakan citra. PAI Python SDK menyediakan metode pai.model.container_serving_spec() yang memungkinkan Anda membuat layanan inferensi menggunakan kode lokal dan citra yang disediakan oleh PAI.

1. Persiapkan File Kode Layanan Inferensi

   Anda perlu menyiapkan kode yang digunakan untuk memuat model, memulai server HTTP, dan memproses permintaan inferensi sebelum menerapkan model. Dalam contoh ini, kode ditulis menggunakan Flask. Contoh kode:

   import json
   from flask import Flask, request
   from PIL import Image
   import os
   import torch
   import torchvision.transforms as transforms
   import numpy as np
   import io
   
   app = Flask(__name__)
   # Model dimuat ke jalur saat ini secara default.  
   MODEL_PATH = "/eas/workspace/model/"
   
   device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
   model = torch.jit.load(os.path.join(MODEL_PATH, "mnist_cnn.pt"), map_location=device).to(device)
   transform = transforms.Compose(
       [transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))]
   )
   
   
   @app.route("/", methods=["POST"])
   def predict():
       # Pra-pemrosesan data gambar.
       im = Image.open(io.BytesIO(request.data))
       input_tensor = transform(im).to(device)
       input_tensor.unsqueeze_(0)
       # Lakukan inferensi dengan model.
       output_tensor = model(input_tensor)
       pred_res =output_tensor.detach().cpu().numpy()[0] 
   
       return json.dumps(pred_res.tolist())
   
   
   if __name__ == '__main__':
       app.run(host="0.0.0.0", port=int(os.environ.get("LISTENING_PORT", 8000)))
   

   Simpan kode di atas ke mesin lokal sehingga Anda dapat mengunggahnya untuk digunakan nanti. Dalam contoh ini, buat direktori infer_src dan simpan kode di atas ke infer_src/run.py. Contoh struktur direktori:

   |-- infer_src # Direktori kode layanan inferensi yang akan diunggah.
       |-- requirements.txt # Opsional. Dependensi pihak ketiga dari layanan inferensi.
       '-- run.py # Skrip layanan inferensi.

2. Buat Objek InferenceSpec Berdasarkan Skrip Lokal dan Citra PyTorch yang Disediakan oleh PAI Melaluipai.model.container_serving_spec.

   from pai.model import InferenceSpec, container_serving_spec
   from pai.image import retrieve, ImageScope
   
   torch_image_uri = retrieve("PyTorch", framework_version="latest", image_scope=ImageScope.INFERENCE).image_uri
   
   inf_spec = container_serving_spec(
       command="python run.py",
       source_dir="./infer_src/",
       image_uri=torch_image_uri,
       requirements=["flask==2.0.0", "Werkzeug==2.2.2", "pillow", "torchvision"],
   )
   print(inf_spec.to_dict())
   

   • Kode dan Perintah Startup Layanan Model

     Direktori skrip lokal yang ditentukan oleh parameter source_dir diunggah ke OSS dan kemudian dipasang ke wadah layanan. Direktori /ml/usercode digunakan secara default.

   • Citra yang Digunakan untuk Layanan Inferensi

     Anda dapat menggunakan metode pai.image.retrieve untuk mendapatkan citra yang disediakan oleh PAI. Tentukan parameter image_scope ke ImageScope.INFERENCE saat Anda mendapatkan citra tersebut.

   • Dependensi Pihak Ketiga dari Layanan Model

     Anda dapat menggunakan parameter requirements untuk menentukan kode atau dependensi layanan model. Dengan cara ini, dependensi diinstal di lingkungan sebelum layanan dimulai.

3. Panggil API Model.deploy untuk menerapkan layanan inferensi online menggunakan model yang telah dilatih dan InferenceSpec.

   from pai.model import Model
   from pai.common.utils import random_str
   import numpy as np
   
   
   m = Model(
       model_data=est.model_data(),
       inference_spec=inf_spec,
   )
   
   predictor = m.deploy(
       service_name="torch_mnist_script_container_{}".format(random_str(6)),
       instance_type="ecs.c6.xlarge",
   )
   

5. Panggil Layanan Inferensi

   1. Persiapkan Gambar MNIST

      import base64
      from PIL import Image
      from IPython import display
      import io
      
      !pip install -q pillow
      # raw_data adalah gambar MNIST, yang sesuai dengan angka 9.
      raw_data = base64.b64decode(b"/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/wAALCAAcABwBAREA/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/9oACAEBAAA/APn+rVhpmoarP5GnWNzeTYz5dvE0jfkoJovNMv8ATmK3tjc2zByhE8TNKc+U2AKY79AM1nUVo6Fplxrmt2WlWUfmXd5MkEQ9WY4H617rdeC/FVgD4O8C2FzpGmpJu1DXbzMMl3IBg7T94p2GwfTJOmeM+Mni5NR1G18K2UkstjoecXnmkLvPPAzWc1FbOh6Zc63rllpVlH5l3eTJBEPVmOB+tXtd1mXX9ZuNUuLe2gmuCGkS2QohbABbBJwTjJ9yelZ1f/2Q==")
      
      im = Image.open(io.BytesIO(raw_data))
      display.display(im)
      

   2. Kirim Permintaan ke Layanan Inferensi

      Layanan inferensi menggunakan data dalam badan permintaan HTTP sebagai input gambar. Metode raw_predict menerima permintaan dengan data bertipe bytes. Selanjutnya, PAI Python SDK menggunakan metode POST untuk menyertakan data inferensi dalam badan permintaan dan mengirimkannya ke layanan inferensi.

      from pai.predictor import RawResponse
      import numpy as np
      
      resp: RawResponse = predictor.raw_predict(data=raw_data)
      print(resp.json())
      
      print(np.argmax(resp.json()))
      

5. Hapus Layanan Setelah Pengujian Selesai

   predictor.delete_service()