1. Tujuan
Ringkasan
Codelab ini akan berfokus pada pembuatan aplikasi Vertex AI Vision secara menyeluruh untuk memantau ukuran antrean menggunakan rekaman video retail. Kita akan menggunakan fitur bawaan Analisis jumlah tamu model Khusus terlatih untuk menangkap hal-hal berikut:
- Hitung jumlah orang yang mengantre.
- Hitung jumlah orang yang dilayani di konter.
Yang akan Anda pelajari
- Cara membuat aplikasi di Vertex AI Vision dan men-deploy-nya
- Cara menyiapkan streaming RTSP menggunakan file video dan menyerap streaming ke Vertex AI Vision menggunakan vaictl dari Jupyter Notebook.
- Cara menggunakan model Occupancy Analytics dan berbagai fiturnya.
- Cara menelusuri video di Media Warehouse Vertex AI Vision dengan penyimpanan Anda.
- Cara menghubungkan output ke BigQuery, menulis kueri SQL untuk mengekstrak insight dari output JSON model dan menggunakan output tersebut untuk memberi label dan menganotasi video asli.
Biaya:
Total biaya untuk menjalankan lab ini di Google Cloud adalah sekitar $2.
2. Sebelum Memulai
Buat project dan aktifkan API:
- Di Konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud. Catatan: Jika Anda tidak berencana untuk menyimpan resource yang dibuat dalam prosedur ini, buat project alih-alih memilih project yang sudah ada. Setelah menyelesaikan langkah-langkah ini, Anda dapat menghapus project, sehingga semua resource yang terkait dengan project tersebut akan dihapus. Buka pemilih project
- Pastikan penagihan diaktifkan untuk project Cloud Anda. Pelajari cara memeriksa apakah penagihan telah diaktifkan pada suatu project.
- Mengaktifkan Compute Engine, Vertex API, Notebook API, dan Vision AI API. Aktifkan API
Membuat akun layanan:
- Di konsol Google Cloud, buka halaman Buat akun layanan. Buka Buat akun layanan
- Pilih project Anda.
- Di kolom Nama akun layanan, masukkan nama. Konsol Google Cloud mengisi kolom Service account ID berdasarkan nama ini. Di kolom Deskripsi akun layanan, masukkan deskripsi. Misalnya, Akun layanan untuk panduan memulai.
- Klik Buat dan lanjutkan.
- Untuk memberikan akses ke project Anda, berikan peran berikut ke akun layanan Anda:
- Vision AI > Editor Vision AI
- Compute Engine > Admin Instance Compute (beta)
- BigQuery > Admin BigQuery .
Di daftar Pilih peran, pilih peran. Untuk peran tambahan, klik Tambahkan peran lain, lalu tambahkan setiap peran tambahan.
- Klik Lanjutkan.
- Klik Selesai untuk menyelesaikan pembuatan akun layanan. Jangan tutup jendela browser Anda. Anda akan menggunakannya pada langkah berikutnya.
3. Menyiapkan Notebook Jupyter
Sebelum membuat Aplikasi di Occupancy Analytics, Anda harus mendaftarkan aliran data yang dapat digunakan nanti oleh Aplikasi.
Dalam tutorial ini, Anda membuat instance Notebook Jupyter yang menghosting video, dan Anda mengirim data video streaming tersebut dari notebook. Kami menggunakan notebook jupyter karena menawarkan fleksibilitas untuk menjalankan perintah shell serta menjalankan kode pra/pasca-pemrosesan kustom di satu tempat yang sangat cocok untuk eksperimen cepat. Kami akan menggunakan notebook ini untuk:
- Jalankan server rtsp sebagai proses latar belakang
- Jalankan perintah vaictl sebagai proses latar belakang
- Jalankan kueri dan pemrosesan kode untuk menganalisis output analisis jumlah tamu
Membuat Notebook Jupyter
Langkah pertama dalam mengirim video dari instance Notebook Jupyter adalah membuat notebook dengan akun layanan yang dibuat di langkah sebelumnya.
- Di konsol, buka halaman Vertex AI. Buka Vertex AI Workbench
- Klik Notebooks yang Dikelola Pengguna
- Klik Notebook Baru > Tensorflow Enterprise 2.6 (dengan LTS) > Tanpa GPU
- Masukkan nama untuk notebook jupyter. Untuk mengetahui informasi selengkapnya, lihat Konvensi penamaan resource.
- Klik OPSI LANJUTAN
- Scroll ke bawah ke Bagian Izin
- Hapus centang opsi Use Compute Engine default service account
- Tambahkan email Akun layanan yang dibuat di langkah sebelumnya. Lalu klik Create.
- Setelah instance dibuat, klik BUKA JUPYTERLAB.
4. Siapkan Notebook untuk streaming video
Sebelum membuat Aplikasi di Occupancy Analytics, Anda harus mendaftarkan aliran data yang dapat digunakan nanti oleh Aplikasi.
Dalam tutorial ini, kita akan menggunakan instance Notebook Jupyter untuk menghosting video, dan Anda mengirim data video streaming tersebut dari terminal Notebook.
Download alat command line vaictl
- Di instance Jupyterlab yang terbuka, Buka Notebook dari peluncur.
- Download alat command line Vertex AI Vision (vaictl), alat command line server rtsp, alat open-cv menggunakan perintah berikut di sel notebook:
!wget -q https://github.com/aler9/rtsp-simple-server/releases/download/v0.20.4/rtsp-simple-server_v0.20.4_linux_amd64.tar.gz
!wget -q https://github.com/google/visionai/releases/download/v0.0.4/visionai_0.0-4_amd64.deb
!tar -xf rtsp-simple-server_v0.20.4_linux_amd64.tar.gz
!pip install opencv-python --quiet
!sudo apt-get -qq remove -y visionai
!sudo apt-get -qq install -y ./visionai_0.0-4_amd64.deb
!sudo apt-get -qq install -y ffmpeg
5. Menyerap file video untuk streaming
Setelah menyiapkan lingkungan notebook Anda dengan alat command line yang diperlukan, Anda dapat menyalin contoh file video, lalu menggunakan vaictl untuk melakukan streaming data video ke aplikasi analisis tingkat keterisian Anda.
Mendaftarkan streaming baru
- Klik tab Stream di panel kiri Vertex AI Vision.
- Klik Tombol Daftar di bagian atas
- Di nama Streaming, masukkan 'queue-stream'
- Di region, pilih region yang sama yang dipilih selama pembuatan Notebook di langkah sebelumnya.
- Klik Register
Menyalin video sampel ke VM
- Di {i>notebook<i} Anda, salin video contoh dengan perintah wget berikut.
!wget -q https://github.com/vagrantism/interesting-datasets/raw/main/video/collective_activity/seq25_h264.mp4
Melakukan streaming video dari VM dan menyerap data ke streaming Anda
- Untuk mengirim file video lokal ini ke aliran data input aplikasi, gunakan perintah berikut di sel notebook Anda. Anda harus melakukan penggantian variabel berikut:
- PROJECT_ID: ID project Google Cloud Anda.
- LOKASI: ID lokasi Anda. Misalnya, us-central1. Untuk mengetahui informasi selengkapnya, lihat Lokasi Cloud.
- LOCAL_FILE: Nama file dari file video lokal. Misalnya,
seq25_h264.mp4.
PROJECT_ID='<Your Google Cloud project ID>'
LOCATION='<Your stream location>'
LOCAL_FILE='seq25_h264.mp4'
STREAM_NAME='queue-stream'
- Mulai rtsp-simple-server tempat kami melakukan streaming file video dengan protokol rtsp
import os
import time
import subprocess
subprocess.Popen(["nohup", "./rtsp-simple-server"], stdout=open('rtsp_out.log', 'a'), stderr=open('rtsp_err.log', 'a'), preexec_fn=os.setpgrp)
time.sleep(5)
- Gunakan alat command line ffmpeg untuk mengulang video dalam streaming rtsp
subprocess.Popen(["nohup", "ffmpeg", "-re", "-stream_loop", "-1", "-i", LOCAL_FILE, "-c", "copy", "-f", "rtsp", f"rtsp://localhost:8554/{LOCAL_FILE.split('.')[0]}"], stdout=open('ffmpeg_out.log', 'a'), stderr=open('ffmpeg_err.log', 'a'), preexec_fn=os.setpgrp)
time.sleep(5)
- Gunakan alat command line vaictl untuk melakukan streaming video dari uri server rtsp ke streaming Vertex AI Vision 'queue-stream' buat di langkah sebelumnya.
subprocess.Popen(["nohup", "vaictl", "-p", PROJECT_ID, "-l", LOCATION, "-c", "application-cluster-0", "--service-endpoint", "visionai.googleapis.com", "send", "rtsp", "to", "streams", "queue-stream", "--rtsp-uri", f"rtsp://localhost:8554/{LOCAL_FILE.split('.')[0]}"], stdout=open('vaictl_out.log', 'a'), stderr=open('vaictl_err.log', 'a'), preexec_fn=os.setpgrp)
Mungkin diperlukan waktu ~100 detik antara memulai operasi penyerapan konversi dan video yang muncul di dasbor.
Setelah proses transfer streaming tersedia, Anda dapat melihat feed video di tab Streaming pada dasbor Vertex AI Vision dengan memilih streaming antrean-streaming.
6. Membuat aplikasi
Langkah pertama adalah membuat aplikasi yang memproses data Anda. Aplikasi dapat dianggap sebagai pipeline otomatis yang menghubungkan hal-hal berikut:
- Penyerapan data: Feed video ditransfer ke dalam streaming.
- Analisis data: Model AI(Computer Vision) dapat ditambahkan setelah penyerapan.
- Penyimpanan data: Kedua versi feed video (streaming asli dan streaming yang diproses oleh model AI) dapat disimpan di media warehouse.
Di konsol Google Cloud, aplikasi direpresentasikan sebagai grafik.
Membuat aplikasi kosong
Sebelum dapat mengisi grafik aplikasi, Anda harus membuat aplikasi kosong terlebih dahulu.
Membuat aplikasi di Konsol Google Cloud.
- Buka Konsol Google Cloud.
- Buka tab Applications pada dasbor Vertex AI Vision. Buka tab Aplikasi
- Klik tombol Buat.
- Masukkan 'queue-app' sebagai nama aplikasi, lalu pilih region Anda.
- Klik Buat.
Menambahkan node komponen aplikasi
Setelah membuat aplikasi kosong, Anda selanjutnya dapat menambahkan tiga node ke grafik aplikasi:
- Node proses transfer: Resource streaming yang menyerap data yang dikirim dari server video rtsp yang Anda buat di notebook.
- Node pemrosesan: Model analisis jumlah tamu yang menindaklanjuti data yang diserap.
- Node penyimpanan: Media warehouse yang menyimpan video yang diproses, dan berfungsi sebagai penyimpanan metadata. Penyimpanan metadata mencakup informasi analisis tentang data video yang ditransfer, dan informasi yang disimpulkan oleh model AI.
Tambahkan node komponen ke aplikasi Anda di konsol.
- Buka tab Applications pada dasbor Vertex AI Vision. Buka tab Aplikasi
Anda akan diarahkan ke visualisasi grafik pipeline pemrosesan.
Menambahkan node penyerapan data
- Untuk menambahkan node aliran data input, pilih opsi Stream di bagian Konektor pada menu samping.
- Di bagian Sumber pada menu Aliran yang terbuka, pilih Tambahkan aliran data.
- Di menu Tambahkan streaming, pilih antrean-streaming.
- Untuk menambahkan aliran data ke grafik aplikasi, klik Tambahkan aliran data.
Menambahkan node pemrosesan data
- Untuk menambahkan node model jumlah tamu, pilih opsi analisis tingkat keterisian di bagian Model khusus pada menu samping.
- Biarkan pilihan default Orang. Hapus centang Kendaraan jika sudah dipilih.
- Di bagian Advanced Options, klik Create Active Zones/Lines
- Gambar zona aktif menggunakan alat Poligon untuk menghitung orang di zona tersebut. Beri label zona yang sesuai
- Klik Panah Kembali di bagian atas.
- Tambahkan pengaturan untuk lama singgah guna mendeteksi kemacetan dengan mengeklik Kotak centang.
Menambahkan node penyimpanan data
- Untuk menambahkan node tujuan output (penyimpanan), pilih opsi VIsion AI Warehouse di bagian Connectors pada menu samping.
- Klik Vertex AI Warehouse Connector untuk membuka menunya, klik Connect warehouse.
- Di menu Connect warehouse, pilih Create new warehouse. Beri nama gudang sebagai queue-warehouse, dan biarkan durasi TTL pada 14 hari.
- Klik tombol Buat untuk menambahkan warehouse.
7. Hubungkan Output ke Tabel BigQuery
Saat Anda menambahkan konektor BigQuery ke aplikasi Vertex AI Vision, semua output model aplikasi yang terhubung akan ditransfer ke tabel target.
Anda dapat membuat tabel BigQuery sendiri dan menentukan tabel tersebut saat menambahkan konektor BigQuery ke aplikasi, atau membiarkan platform aplikasi Vertex AI Vision membuat tabel tersebut secara otomatis.
Pembuatan tabel otomatis
Jika mengizinkan platform aplikasi Vertex AI Vision membuat tabel secara otomatis, Anda dapat menentukan opsi ini saat menambahkan node konektor BigQuery.
Kondisi set data dan tabel berikut berlaku jika Anda ingin menggunakan pembuatan tabel otomatis:
- Set data: Nama set data yang dibuat secara otomatis adalah visionai_dataset.
- Tabel: Nama tabel yang dibuat secara otomatis adalah visionai_dataset.APPLICATION_ID.
- Penanganan error:
- Jika tabel dengan nama yang sama dalam set data yang sama tidak ada, pembuatan otomatis tidak akan dilakukan.
- Buka tab Applications pada dasbor Vertex AI Vision. Buka tab Aplikasi
- Pilih Lihat aplikasi di samping nama aplikasi Anda dari daftar tersebut.
- Di halaman builder aplikasi, pilih BigQuery dari bagian Konektor.
- Biarkan kolom BigQuery path kosong.
- Di metadata toko dari: hanya pilih 'Analisis jumlah tamu' dan hapus centang aliran data.
Grafik aplikasi akhir akan terlihat seperti ini:
8. Men-deploy aplikasi untuk digunakan
Setelah Anda membangun aplikasi end-to-end dengan semua komponen yang diperlukan, langkah terakhir untuk menggunakan aplikasi adalah men-deploy-nya.
- Buka tab Applications pada dasbor Vertex AI Vision. Buka tab Aplikasi
- Pilih View app di samping aplikasi queue-app dalam daftar.
- Dari halaman Studio, klik tombol Deploy.
- Dalam dialog konfirmasi berikut, klik Deploy. Operasi deployment mungkin memerlukan waktu beberapa menit untuk diselesaikan. Setelah deployment selesai, tanda centang hijau akan muncul di samping node.
9. Telusuri konten video di gudang penyimpanan
Setelah menyerap data video ke dalam aplikasi pemrosesan, Anda dapat melihat data video yang dianalisis dan menelusuri data berdasarkan informasi analisis tingkat keterisian.
- Buka tab Warehouses pada dasbor Vertex AI Vision. Buka tab Warehouse
- Temukan gudang gudang antrean dalam daftar, lalu klik Lihat aset.
- Di bagian Jumlah orang, tetapkan nilai Min ke 1, dan nilai Maksimum ke 5.
- Untuk memfilter data video yang diproses dan disimpan di Media Warehouse Vertex AI Vision, klik Telusuri.
Tampilan data video tersimpan yang cocok dengan kriteria penelusuran di Konsol Google Cloud.
10. Menganotasi dan Menganalisis Output menggunakan Tabel BigQuery
- Di Notebook, lakukan inisialisasi variabel berikut dalam sel.
DATASET_ID='vision_ai_dataset'
bq_table=f'{PROJECT_ID}.{DATASET_ID}.queue-app'
frame_buffer_size=10000
frame_buffer_error_milliseconds=5
dashboard_update_delay_seconds=3
rtsp_url='rtsp://localhost:8554/seq25_h264'
- Sekarang kita akan merekam frame dari streaming rtsp menggunakan kode berikut:
import cv2
import threading
from collections import OrderedDict
from datetime import datetime, timezone
frame_buffer = OrderedDict()
frame_buffer_lock = threading.Lock()
stream = cv2.VideoCapture(rtsp_url)
def read_frames(stream):
global frames
while True:
ret, frame = stream.read()
frame_ts = datetime.now(timezone.utc).timestamp() * 1000
if ret:
with frame_buffer_lock:
while len(frame_buffer) >= frame_buffer_size:
_ = frame_buffer.popitem(last=False)
frame_buffer[frame_ts] = frame
frame_buffer_thread = threading.Thread(target=read_frames, args=(stream,))
frame_buffer_thread.start()
print('Waiting for stream initialization')
while not list(frame_buffer.keys()): pass
print('Stream Initialized')
- Tarik stempel waktu data dan informasi anotasi dari tabel bigquery dan buat direktori untuk menyimpan gambar bingkai yang diambil:
from google.cloud import bigquery
import pandas as pd
client = bigquery.Client(project=PROJECT_ID)
query = f"""
SELECT MAX(ingestion_time) AS ts
FROM `{bq_table}`
"""
bq_max_ingest_ts_df = client.query(query).to_dataframe()
bq_max_ingest_epoch = str(int(bq_max_ingest_ts_df['ts'][0].timestamp()*1000000))
bq_max_ingest_ts = bq_max_ingest_ts_df['ts'][0]
print('Preparing to pull records with ingestion time >', bq_max_ingest_ts)
if not os.path.exists(bq_max_ingest_epoch):
os.makedirs(bq_max_ingest_epoch)
print('Saving output frames to', bq_max_ingest_epoch)
- Anotasikan frame menggunakan kode berikut:
import json
import base64
import numpy as np
from IPython.display import Image, display, HTML, clear_output
im_width = stream.get(cv2.CAP_PROP_FRAME_WIDTH)
im_height = stream.get(cv2.CAP_PROP_FRAME_HEIGHT)
dashdelta = datetime.now()
framedata = {}
cntext = lambda x: {y['entity']['labelString']: y['count'] for y in x}
try:
while True:
try:
annotations_df = client.query(f'''
SELECT ingestion_time, annotation
FROM `{bq_table}`
WHERE ingestion_time > TIMESTAMP("{bq_max_ingest_ts}")
''').to_dataframe()
except ValueError as e:
continue
bq_max_ingest_ts = annotations_df['ingestion_time'].max()
for _, row in annotations_df.iterrows():
with frame_buffer_lock:
frame_ts = np.asarray(list(frame_buffer.keys()))
delta_ts = np.abs(frame_ts - (row['ingestion_time'].timestamp() * 1000))
delta_tx_idx = delta_ts.argmin()
closest_ts_delta = delta_ts[delta_tx_idx]
closest_ts = frame_ts[delta_tx_idx]
if closest_ts_delta > frame_buffer_error_milliseconds: continue
image = frame_buffer[closest_ts]
annotations = json.loads(row['annotation'])
for box in annotations['identifiedBoxes']:
image = cv2.rectangle(
image,
(
int(box['normalizedBoundingBox']['xmin']*im_width),
int(box['normalizedBoundingBox']['ymin']*im_height)
),
(
int((box['normalizedBoundingBox']['xmin'] + box['normalizedBoundingBox']['width'])*im_width),
int((box['normalizedBoundingBox']['ymin'] + box['normalizedBoundingBox']['height'])*im_height)
),
(255, 0, 0), 2
)
img_filename = f"{bq_max_ingest_epoch}/{row['ingestion_time'].timestamp() * 1000}.png"
cv2.imwrite(img_filename, image)
binimg = base64.b64encode(cv2.imencode('.jpg', image)[1]).decode()
curr_framedata = {
'path': img_filename,
'timestamp_error': closest_ts_delta,
'counts': {
**{
k['annotation']['displayName'] : cntext(k['counts'])
for k in annotations['stats']["activeZoneCounts"]
},
'full-frame': cntext(annotations['stats']["fullFrameCount"])
}
}
framedata[img_filename] = curr_framedata
if (datetime.now() - dashdelta).total_seconds() > dashboard_update_delay_seconds:
dashdelta = datetime.now()
clear_output()
display(HTML(f'''
<h1>Queue Monitoring Application</h1>
<p>Live Feed of the queue camera:</p>
<p><img alt="" src="{img_filename}" style="float: left;"/></a></p>
<table border="1" cellpadding="1" cellspacing="1" style="width: 500px;">
<caption>Current Model Outputs</caption>
<thead>
<tr><th scope="row">Metric</th><th scope="col">Value</th></tr>
</thead>
<tbody>
<tr><th scope="row">Serving Area People Count</th><td>{curr_framedata['counts']['serving-zone']['Person']}</td></tr>
<tr><th scope="row">Queueing Area People Count</th><td>{curr_framedata['counts']['queue-zone']['Person']}</td></tr>
<tr><th scope="row">Total Area People Count</th><td>{curr_framedata['counts']['full-frame']['Person']}</td></tr>
<tr><th scope="row">Timestamp Error</th><td>{curr_framedata['timestamp_error']}</td></tr>
</tbody>
</table>
<p> </p>
'''))
except KeyboardInterrupt:
print('Stopping Live Monitoring')
- Hentikan tugas anotasi menggunakan tombol Stop di panel menu notebook
- Anda dapat mengunjungi kembali setiap frame menggunakan kode berikut:
from IPython.html.widgets import Layout, interact, IntSlider
imgs = sorted(list(framedata.keys()))
def loadimg(frame):
display(framedata[imgs[frame]])
display(Image(open(framedata[imgs[frame]]['path'],'rb').read()))
interact(loadimg, frame=IntSlider(
description='Frame #:',
value=0,
min=0, max=len(imgs)-1, step=1,
layout=Layout(width='100%')))
11. Selamat
Selamat, kamu telah menyelesaikan lab!
Pembersihan
Agar tidak menimbulkan biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam tutorial ini, hapus project yang berisi resource, atau simpan project dan hapus resource satu per satu.
Menghapus project
Menghapus resource satu per satu
Referensi
https://cloud.google.com/vision-ai/docs/overview
https://cloud.google.com/vision-ai/docs/occupancy-count-tutorial