Men-deploy sistem inferensi TensorFlow yang skalabel

Last reviewed 2023-11-02 UTC

Dokumen ini menjelaskan cara men-deploy arsitektur referensi yang dijelaskan dalam Sistem inferensi TensorFlow yang skalabel.

Seri ini ditujukan bagi developer yang sudah memahami Google Kubernetes Engine dan framework machine learning (ML), termasuk TensorFlow dan NVIDIA TensorRT.

Setelah menyelesaikan deployment ini, lihat Mengukur dan menyesuaikan performa sistem inferensi TensorFlow.

Arsitektur

Diagram berikut menunjukkan arsitektur sistem inferensi.

Arsitektur sistem inferensi.

Cloud Load Balancing mengirimkan traffic permintaan ke cluster GKE terdekat. Cluster berisi Pod untuk setiap node. Di setiap Pod, Server Inferensi Triton menyediakan layanan inferensi (untuk menayangkan model ResNet-50), dan GPU NVIDIA T4 meningkatkan performa. Server pemantauan di cluster mengumpulkan data metrik tentang penggunaan GPU dan penggunaan memori.

Untuk mengetahui detailnya, lihat Sistem inferensi TensorFlow yang skalabel.

Tujuan

  • Download model ResNet-50 yang telah dilatih sebelumnya, dan gunakan integrasi TensorFlow dengan TensorRT (TF-TRT) untuk menerapkan pengoptimalan
  • Menayangkan model ResNet-50 dari Server Inferensi NVIDIA Triton
  • Membangun sistem pemantauan untuk Triton dengan menggunakan Prometheus dan Grafana
  • Membuat alat pengujian beban menggunakan Locust

Biaya

Selain GPU NVIDIA T4, dalam deployment ini, Anda akan menggunakan komponen Google Cloud yang dapat ditagih berikut:

Untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda, gunakan kalkulator harga.

Setelah menyelesaikan deployment ini, jangan hapus resource yang Anda buat. Anda memerlukan resource ini saat mengukur dan menyesuaikan deployment.

Sebelum memulai

  1. Login ke akun Google Cloud Anda. Jika Anda baru menggunakan Google Cloud, buat akun untuk mengevaluasi performa produk kami dalam skenario dunia nyata. Pelanggan baru juga mendapatkan kredit gratis senilai $300 untuk menjalankan, menguji, dan men-deploy workload.

  2. Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

    Buka pemilih project

  3. Make sure that billing is enabled for your Google Cloud project.

  4. Aktifkan API GKE.

    Mengaktifkan API

    5.

  5. Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

    Buka pemilih project

  6. Make sure that billing is enabled for your Google Cloud project.

  7. Aktifkan API GKE.

    Mengaktifkan API

    8.

Membangun model yang dioptimalkan dengan TF-TRT

Di bagian ini, Anda akan membuat lingkungan kerja dan mengoptimalkan model yang telah dilatih sebelumnya.

Model terlatih menggunakan set data palsu di gs://cloud-tpu-test-datasets/fake_imagenet/. Ada juga salinan model terlatih di lokasi Cloud Storage di gs://solutions-public-assets/tftrt-tutorial/resnet/export/1584366419/.

Menciptakan lingkungan kerja

Untuk lingkungan kerja, Anda membuat instance Compute Engine menggunakan Deep Learning VM Image. Anda akan mengoptimalkan dan mengukur model ResNet-50 dengan TensorRT pada instance ini.

  1. Di konsol Google Cloud, aktifkan Cloud Shell.

    Aktifkan Cloud Shell

  2. Deploy instance bernama working-vm:

    gcloud config set project PROJECT_ID
gcloud config set compute/zone us-west1-b
gcloud compute instances create working-vm \
    --scopes cloud-platform \
    --image-family common-cu113 \
    --image-project deeplearning-platform-release \
    --machine-type n1-standard-8 \
    --min-cpu-platform="Intel Skylake" \
    --accelerator=type=nvidia-tesla-t4,count=1 \
    --boot-disk-size=200GB \
    --maintenance-policy=TERMINATE \
    --metadata="install-nvidia-driver=True"

    Ganti PROJECT_ID dengan ID project Google Cloud yang Anda buat sebelumnya.

    Perintah ini meluncurkan instance Compute Engine menggunakan NVIDIA T4. Saat booting pertama, driver akan otomatis menginstal driver GPU NVIDIA yang kompatibel dengan TensorRT 5.1.5.

Membuat file model dengan pengoptimalan yang berbeda

Di bagian ini, Anda akan menerapkan pengoptimalan berikut ke model ResNet-50 asli menggunakan TF-TRT:

  • Pengoptimalan grafik
  • Konversi ke FP16 dengan pengoptimalan grafik
  • Kuantisasi dengan INT8 dengan pengoptimalan grafik

Untuk mengetahui detail tentang pengoptimalan ini, lihat Pengoptimalan performa.

  1. Di konsol Google Cloud, buka Compute Engine > VM instances.

    Buka Instance VM

    Anda akan melihat instance working-vm yang dibuat sebelumnya.

  2. Untuk membuka konsol terminal instance, klik SSH.

    Gunakan terminal ini untuk menjalankan perintah lainnya dalam dokumen ini.

  3. Di terminal, clone repositori yang diperlukan dan ubah direktori saat ini:

    cd $HOME
git clone https://github.com/GoogleCloudPlatform/gke-tensorflow-inference-system-tutorial
cd gke-tensorflow-inference-system-tutorial/server

  4. Download model ResNet-50 yang telah dilatih sebelumnya ke direktori lokal:

    mkdir -p models/resnet/original/00001
gcloud storage cp gs://solutions-public-assets/tftrt-tutorial/resnet/export/1584366419/* models/resnet/original/00001 --recursive

  5. Buat image container yang berisi alat pengoptimalan untuk TF-TRT:

    docker build ./ -t trt-optimizer
docker image list

    Perintah terakhir menampilkan tabel repositori.

  6. Di tabel, pada baris untuk repositori tft-optimizer, salin ID gambar.

  7. Terapkan pengoptimalan (pengoptimalan grafik, konversi ke FP16, dan kuantisasi dengan INT8) ke model asli:

    export IMAGE_ID=IMAGE_ID

nvidia-docker run --rm \
    -v `pwd`/models/:/workspace/models ${IMAGE_ID} \
    --input-model-dir='models/resnet/original/00001' \
    --output-dir='models/resnet' \
    --precision-mode='FP32' \
    --batch-size=64

nvidia-docker run --rm \
    -v `pwd`/models/:/workspace/models ${IMAGE_ID} \
    --input-model-dir='models/resnet/original/00001' \
    --output-dir='models/resnet' \
    --precision-mode='FP16' \
    --batch-size=64

nvidia-docker run --rm \
    -v `pwd`/models/:/workspace/models ${IMAGE_ID} \
    --input-model-dir='models/resnet/original/00001' \
    --output-dir='models/resnet' \
    --precision-mode='INT8' \
    --batch-size=64 \
    --calib-image-dir='gs://cloud-tpu-test-datasets/fake_imagenet/' \
    --calibration-epochs=10

    Ganti IMAGE_ID dengan ID gambar untuk tft-optimizer yang Anda salin di langkah sebelumnya.

    Opsi --calib-image-dir menentukan lokasi data pelatihan yang digunakan untuk model terlatih. Data pelatihan yang sama digunakan untuk kalibrasi untuk kuantisasi INT8. Proses kalibrasi dapat memerlukan waktu sekitar 5 menit.

    Saat perintah selesai berjalan, baris output terakhir akan mirip dengan berikut, dengan model yang dioptimalkan disimpan di ./models/resnet:

    INFO:tensorflow:SavedModel written to: models/resnet/INT8/00001/saved_model.pb

    Struktur direktorinya mirip dengan yang berikut:

    models
└── resnet
    ├── FP16
    │   └── 00001
    │       ├── saved_model.pb
    │       └── variables
    ├── FP32
    │   └── 00001
    │       ├── saved_model.pb
    │       └── variables
    ├── INT8
    │   └── 00001
    │       ├── saved_model.pb
    │       └── variables
    └── original
        └── 00001
            ├── saved_model.pb
            └── variables
                ├── variables.data-00000-of-00001
                └── variables.index

Tabel berikut meringkas hubungan antara direktori dan pengoptimalan.

Direktori Pengoptimalan
FP16 Konversi ke FP16 selain pengoptimalan grafik
FP32 Pengoptimalan grafik
INT8 Kuantisasi dengan INT8 selain pengoptimalan grafik
original Model asli (tanpa pengoptimalan dengan TF-TRT)

Men-deploy server inferensi

Di bagian ini, Anda akan men-deploy server Triton dengan lima model. Pertama, upload biner model yang Anda buat sebelumnya ke Cloud Storage. Kemudian, buat cluster GKE dan deploy server Triton di cluster tersebut.

Upload biner model

  • Di terminal SSH, upload biner model dan file konfigurasi config.pbtxt ke bucket penyimpanan:

    export PROJECT_ID=PROJECT_ID
export BUCKET_NAME=${PROJECT_ID}-models

mkdir -p original/1/model/
cp -r models/resnet/original/00001/* original/1/model/
cp original/config.pbtxt original/1/model/
cp original/imagenet1k_labels.txt original/1/model/

mkdir -p tftrt_fp32/1/model/
cp -r models/resnet/FP32/00001/* tftrt_fp32/1/model/
cp tftrt_fp32/config.pbtxt tftrt_fp32/1/model/
cp tftrt_fp32/imagenet1k_labels.txt tftrt_fp32/1/model/

mkdir -p tftrt_fp16/1/model/
cp -r models/resnet/FP16/00001/* tftrt_fp16/1/model/
cp tftrt_fp16/config.pbtxt tftrt_fp16/1/model/
cp tftrt_fp16/imagenet1k_labels.txt tftrt_fp16/1/model/

mkdir -p tftrt_int8/1/model/
cp -r models/resnet/INT8/00001/* tftrt_int8/1/model/
cp tftrt_int8/config.pbtxt tftrt_int8/1/model/
cp tftrt_int8/imagenet1k_labels.txt tftrt_int8/1/model/

mkdir -p tftrt_int8_bs16_count4/1/model/
cp -r models/resnet/INT8/00001/* tftrt_int8_bs16_count4/1/model/
cp tftrt_int8_bs16_count4/config.pbtxt tftrt_int8_bs16_count4/1/model/
cp tftrt_int8_bs16_count4/imagenet1k_labels.txt tftrt_int8_bs16_count4/1/model/

gcloud storage buckets create gs://${BUCKET_NAME}
gcloud storage cp original tftrt_fp32 tftrt_fp16 tftrt_int8 tftrt_int8_bs16_count4 \
    gs://${BUCKET_NAME}/resnet/ --recursive

    Ganti PROJECT_ID dengan ID project Google Cloud yang Anda buat sebelumnya.

    Parameter penyesuaian berikut ditentukan dalam file config.pbtxt:

    • Nama model
    • Nama tensor input dan nama tensor output
    • Alokasi GPU untuk setiap model
    • Ukuran batch dan jumlah grup instance

    Sebagai contoh, file original/1/model/config.pbtxt berisi konten berikut:

    name: "original"
platform: "tensorflow_savedmodel"
max_batch_size: 64
input {
    name: "input"
    data_type: TYPE_FP32
    format: FORMAT_NHWC
    dims: [ 224, 224, 3 ]
}
output {
    name: "probabilities"
    data_type: TYPE_FP32
    dims: 1000
    label_filename: "imagenet1k_labels.txt"
}
default_model_filename: "model"
instance_group [
  {
    count: 1
    kind: KIND_GPU
  }
]
dynamic_batching {
  preferred_batch_size: [ 64 ]
  max_queue_delay_microseconds: 20000
}

Untuk mengetahui detail tentang ukuran batch dan jumlah grup instance, lihat Pengoptimalan performa.

Tabel berikut merangkum lima model yang Anda deploy di bagian ini.

Nama model Pengoptimalan
original Model asli (tanpa pengoptimalan dengan TF-TRT)
tftrt_fp32 Pengoptimalan grafik
(batch size=64, instance groups=1)
tftrt_fp16 Konversi ke FP16 selain pengoptimalan grafik
(ukuran batch=64, grup instance=1)
tftrt_int8 Kuantisasi dengan INT8 selain pengoptimalan grafik
(ukuran tumpukan=64, grup instance=1)
tftrt_int8_bs16_count4 Kuantisasi dengan INT8 selain pengoptimalan grafik
(ukuran tumpukan=16, grup instance=4)

Men-deploy server inferensi menggunakan Triton

  1. Di terminal SSH, instal dan konfigurasikan paket autentikasi, yang mengelola cluster GKE:

    export USE_GKE_GCLOUD_AUTH_PLUGIN=True
sudo apt-get install google-cloud-sdk-gke-gcloud-auth-plugin

  2. Buat cluster GKE dan node pool GPU dengan node komputasi yang menggunakan GPU NVIDIA T4:

    gcloud auth login
gcloud config set compute/zone us-west1-b
gcloud container clusters create tensorrt-cluster \
    --num-nodes=20
gcloud container node-pools create t4-gpu-pool \
    --num-nodes=1 \
    --machine-type=n1-standard-8 \
    --cluster=tensorrt-cluster \
    --accelerator type=nvidia-tesla-t4,count=1

    Flag --num-nodes menentukan 20 instance untuk cluster GKE dan satu instance untuk kumpulan node GPU t4-gpu-pool.

    Kumpulan node GPU terdiri dari satu instance n1-standard-8 dengan GPU NVIDIA T4. Jumlah instance GPU harus sama dengan atau lebih besar dari pod server inferensi, karena GPU NVIDIA T4 tidak dapat digunakan bersama oleh beberapa pod pada instance yang sama.

  3. Tampilkan informasi cluster:

    gcloud container clusters list

    Outputnya mirip dengan yang berikut ini:

    NAME              LOCATION    MASTER_VERSION  MASTER_IP      MACHINE_TYPE   NODE_VERSION    NUM_NODES  STATUS
tensorrt-cluster  us-west1-b  1.14.10-gke.17  XX.XX.XX.XX    n1-standard-1  1.14.10-gke.17  21         RUNNING

  4. Tampilkan informasi kumpulan node:

    gcloud container node-pools list --cluster tensorrt-cluster

    Outputnya mirip dengan yang berikut ini:

    NAME          MACHINE_TYPE   DISK_SIZE_GB  NODE_VERSION
default-pool  n1-standard-1  100           1.14.10-gke.17
t4-pool       n1-standard-8  100           1.14.10-gke.17

  5. Aktifkan beban kerja daemonSet:

    gcloud container clusters get-credentials tensorrt-cluster
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml

    Perintah ini memuat driver GPU NVIDIA pada node di kumpulan node GPU. Kode ini juga otomatis akan memuat driver saat Anda menambahkan node baru ke kumpulan node GPU.

  6. Deploy server inferensi di cluster:

    sed -i.bak "s/YOUR-BUCKET-NAME/${PROJECT_ID}-models/" trtis_deploy.yaml
kubectl create -f trtis_service.yaml
kubectl create -f trtis_deploy.yaml

  7. Tunggu beberapa menit sampai layanan tersedia.

  8. Dapatkan alamat clusterIP Triton dan simpan alamat tersebut pada variabel lingkungan:

    export TRITON_IP=$(kubectl get svc inference-server \
  -o "jsonpath={.spec['clusterIP']}")
echo ${TRITON_IP}

Pada tahap ini, server inferensi menayangkan empat model ResNet-50 yang telah Anda buat di bagian Membuat file model dengan pengoptimalan yang berbeda. Klien dapat menentukan model yang akan digunakan saat mengirim permintaan inferensi.

Men-deploy server pemantauan dengan Prometheus dan Grafana

  1. Di terminal SSH, deploy server Prometheus pada cluster:

    sed -i.bak "s/CLUSTER-IP/${TRITON_IP}/" prometheus-configmap.yml
kubectl create namespace monitoring
kubectl apply -f prometheus-service.yml -n monitoring
kubectl create -f clusterRole.yml
kubectl create -f prometheus-configmap.yml -n monitoring
kubectl create -f prometheus-deployment.yml -n monitoring

  2. Dapatkan URL endpoint dari layanan Prometheus.

    ip_port=$(kubectl get svc prometheus-service \
  -o "jsonpath={.spec['clusterIP']}:{.spec['ports'][0]['port']}" -n monitoring)
echo "http://${ip_port}"

    Catat URL endpoint Prometheus, karena Anda akan menggunakannya untuk mengonfigurasi Grafana nanti.

  3. Deploy server Grafana pada cluster:

    kubectl create -f grafana-service.yml -n monitoring
kubectl create -f grafana-deployment.yml -n monitoring

  4. Tunggu beberapa menit hingga semua layanan tersedia.

  5. Mendapatkan URL endpoint dari layanan Grafana.

    ip_port=$(kubectl get svc grafana-service \
  -o "jsonpath={.status['loadBalancer']['ingress'][0]['ip']}:{.spec['ports'][0]['port']}" -n monitoring)
echo "http://${ip_port}"

    Catat URL endpoint Grafana yang akan digunakan di langkah berikutnya.

  6. Di browser web, buka URL Grafana yang Anda catat di langkah sebelumnya.

  7. Login dengan ID pengguna dan sandi default (admin dan admin). Saat diminta, ubah sandi default.

  8. Klik Add your first data source, lalu di daftar Time series database, pilih Prometheus.

  9. Di tab Settings, di kolom URL, masukkan URL endpoint Prometheus yang Anda catat sebelumnya.

  10. Klik Save and Test, lalu kembali ke layar utama.

  11. Tambahkan metrik pemantauan untuk nv_gpu_utilization:

    1. Klik Create your first dashboard, lalu klik Add visualization.
    2. Di daftar Sumber data, pilih Prometheus.

    3. Di tab Query, di kolom Metric, masukkan nv_gpu_utilization.

    4. Di bagian Opsi panel, di kolom Judul, masukkan GPU Utilization, lalu klik Terapkan.

      Halaman ini menampilkan panel untuk penggunaan GPU.

  12. Tambahkan metrik pemantauan untuk nv_gpu_memory_used_bytes:

    1. Klik Tambahkan, lalu pilih Visualisasi.

    2. Di tab Query, di kolom Metric, masukkan nv_gpu_memory_used_bytes.

    3. Di bagian Opsi panel, di kolom Judul, masukkan GPU Memory Used, lalu klik Simpan.

  13. Untuk menambahkan dasbor, di panel Simpan dasbor, klik Simpan.

    Anda akan melihat grafik untuk Pemakaian GPU dan Memori GPU yang Digunakan.

Men-deploy alat pengujian beban

Di bagian ini, Anda akan men-deploy alat pengujian beban Locust di GKE, dan menghasilkan beban kerja untuk mengukur performa server inferensi.

  1. Di terminal SSH, build image Docker yang berisi library klien Triton, lalu upload ke Container Registry:

    cd ../client
git clone https://github.com/triton-inference-server/server
cd server
git checkout r19.05
sed -i.bak "s/bootstrap.pypa.io\/get-pip.py/bootstrap.pypa.io\/pip\/2.7\/get-pip.py/" Dockerfile.client
docker build -t tritonserver_client -f Dockerfile.client .
gcloud auth configure-docker
docker tag tritonserver_client \
    gcr.io/${PROJECT_ID}/tritonserver_client
docker push gcr.io/${PROJECT_ID}/tritonserver_client

    Proses build dapat memerlukan waktu sekitar 5 menit. Setelah proses selesai, perintah prompt akan muncul di terminal SSH.

  2. Setelah proses build selesai, build image Docker untuk menghasilkan beban kerja pengujian, lalu upload ke Container Registry:

    cd ..
sed -i.bak "s/YOUR-PROJECT-ID/${PROJECT_ID}/" Dockerfile
docker build -t locust_tester -f Dockerfile .
docker tag locust_tester gcr.io/${PROJECT_ID}/locust_tester
docker push gcr.io/${PROJECT_ID}/locust_tester

    Jangan mengubah atau mengganti YOUR-PROJECT-ID dalam perintah.

    Image ini dibuat dari image yang telah Anda buat di langkah sebelumnya.

  3. Deploy file Locust service_master.yaml dan deployment_master.yaml:

    sed -i.bak "s/YOUR-PROJECT-ID/${PROJECT_ID}/" deployment_master.yaml
sed -i.bak "s/CLUSTER-IP-TRTIS/${TRITON_IP}/" deployment_master.yaml

kubectl create namespace locust
kubectl create configmap locust-config --from-literal model=original --from-literal saddr=${TRITON_IP} --from-literal rps=10 -n locust

kubectl apply -f service_master.yaml -n locust
kubectl apply -f deployment_master.yaml -n locust

    Resource configmap digunakan untuk menentukan model machine learning yang menjadi tujuan pengiriman permintaan klien untuk inferensi.

  4. Tunggu beberapa menit sampai layanan tersedia.

  5. Dapatkan alamat clusterIP dari klien locust-master, dan simpan alamat tersebut dalam variabel lingkungan:

    export LOCUST_MASTER_IP=$(kubectl get svc locust-master -n locust \
    -o "jsonpath={.spec['clusterIP']}")
echo ${LOCUST_MASTER_IP}

  6. Men-deploy klien Locust

    sed -i.bak "s/YOUR-PROJECT-ID/${PROJECT_ID}/" deployment_slave.yaml
sed -i.bak "s/CLUSTER-IP-LOCUST-MASTER/${LOCUST_MASTER_IP}/" deployment_slave.yaml
kubectl apply -f deployment_slave.yaml -n locust

    Perintah ini men-deploy 10 Pod klien Locust yang dapat digunakan untuk membuat workload pengujian. Jika tidak dapat membuat cukup permintaan dengan jumlah klien saat ini, Anda dapat mengubah jumlah Pod menggunakan perintah berikut:

    kubectl scale deployment/locust-slave --replicas=20 -n locust

    Jika kapasitas cluster default tidak cukup untuk meningkatkan jumlah replika, maka sebaiknya jumlah node di cluster GKE dinaikkan

  7. Salin URL konsol Locust, lalu buka URL ini di browser web:

    export LOCUST_IP=$(kubectl get svc locust-master -n locust \
     -o "jsonpath={.status.loadBalancer.ingress[0].ip}")
echo "http://${LOCUST_IP}:8089"

    Konsol Locust akan terbuka, dan Anda dapat membuat beban kerja pengujian dari konsol tersebut.

Memeriksa Pod yang berjalan

Untuk memastikan bahwa komponen berhasil di-deploy, pastikan Pod sedang berjalan.

  1. Di terminal SSH, periksa Pod server inferensi:

    kubectl get pods

    Outputnya mirip dengan hal berikut ini:

    NAME                                READY   STATUS    RESTARTS   AGE
inference-server-67786cddb4-qrw6r   1/1     Running   0          83m

    Jika Anda tidak mendapatkan output yang diharapkan, pastikan Anda telah menyelesaikan langkah-langkah di Men-deploy server inferensi menggunakan Triton.

  2. Periksa Pod Locust

    kubectl get pods -n locust

    Outputnya mirip dengan hal berikut ini:

    NAME                                READY   STATUS    RESTARTS   AGE
locust-master-75f6f6d4bc-ttllr      1/1     Running   0          10m
locust-slave-76ddb664d9-8275p       1/1     Running   0          2m36s
locust-slave-76ddb664d9-f45ww       1/1     Running   0          2m36s
locust-slave-76ddb664d9-q95z9       1/1     Running   0          2m36s

    Jika Anda tidak mendapatkan output yang diharapkan, pastikan Anda telah menyelesaikan langkah-langkah di Men-deploy alat pengujian beban.

  3. Periksa Pod pemantauan:

    kubectl get pods -n monitoring

    Outputnya mirip dengan hal berikut ini:

    NAME                                     READY   STATUS    RESTARTS   AGE
grafana-deployment-644bbcb84-k6t7v       1/1     Running   0          79m
prometheus-deployment-544b9b9f98-hl7q8   1/1     Running   0          81m

    Jika Anda tidak mendapatkan output yang diharapkan, pastikan Anda telah menyelesaikan langkah-langkah di Men-deploy server pemantauan dengan Prometheus dan Grafana.

Pada bagian selanjutnya dari seri ini, Anda akan menggunakan sistem server inferensi ini untuk mempelajari bagaimana berbagai pengoptimalan meningkatkan performa dan cara untuk menafsirkan pengoptimalan tersebut. Untuk langkah berikutnya, lihat Mengukur dan menyesuaikan performa sistem inferensi TensorFlow.

Langkah selanjutnya