Jalankan beberapa model pembelajaran mendalam di GPU dengan titik akhir multi-model Amazon SageMaker

Saat adopsi AI semakin cepat di seluruh industri, pelanggan membangun model canggih yang memanfaatkan terobosan ilmiah baru dalam pembelajaran mendalam. Model generasi berikutnya ini memungkinkan Anda untuk mencapai kinerja canggih seperti manusia di bidang pemrosesan bahasa alami (NLP), visi komputer, pengenalan suara, penelitian medis, keamanan siber, prediksi struktur protein, dan banyak lainnya. . Misalnya, model bahasa besar seperti GPT-3, OPT, dan BLOOM dapat menerjemahkan, meringkas, dan menulis teks dengan nuansa seperti manusia. Dalam ruang visi komputer, model difusi teks-ke-gambar seperti DALL-E dan Imagen dapat membuat gambar fotorealistik dari bahasa alami dengan tingkat pemahaman visual dan bahasa yang lebih tinggi dari dunia di sekitar kita. Model multi-modal ini menyediakan fitur yang lebih kaya untuk berbagai tugas hilir dan kemampuan untuk menyempurnakannya untuk domain tertentu, dan mereka menghadirkan peluang bisnis yang kuat bagi pelanggan kami.

Model pembelajaran mendalam ini terus berkembang dalam hal ukuran, dan biasanya berisi miliaran parameter model untuk menskalakan kinerja model untuk berbagai tugas, seperti pembuatan gambar, peringkasan teks, terjemahan bahasa, dan banyak lagi. Ada juga kebutuhan untuk menyesuaikan model ini untuk memberikan pengalaman yang sangat personal kepada individu. Akibatnya, lebih banyak model sedang dikembangkan dengan menyempurnakan model ini untuk berbagai tugas hilir. Untuk memenuhi sasaran latensi dan throughput aplikasi AI, instans GPU lebih disukai daripada instans CPU (mengingat penawaran daya komputasi GPU). Namun, instans GPU mahal dan biaya dapat bertambah jika Anda menerapkan lebih dari 10 model. Meskipun model ini berpotensi menghadirkan aplikasi AI yang berdampak, mungkin sulit untuk menskalakan model pembelajaran mendalam ini dengan cara yang hemat biaya karena ukuran dan jumlah modelnya.

Amazon SageMaker titik akhir multi-model (MME) menyediakan cara yang skalabel dan hemat biaya untuk menerapkan sejumlah besar model pembelajaran mendalam. MME adalah pilihan hosting populer untuk menampung ratusan model berbasis CPU di antara pelanggan seperti Zendesk, Veeva, dan AT&T. Sebelumnya, Anda memiliki opsi terbatas untuk menerapkan ratusan model pembelajaran mendalam yang memerlukan komputasi yang dipercepat dengan GPU. Hari ini, kami mengumumkan dukungan MME untuk GPU. Sekarang Anda dapat menerapkan ribuan model pembelajaran mendalam di balik satu titik akhir SageMaker. MME sekarang dapat menjalankan beberapa model pada inti GPU, berbagi instans GPU di belakang titik akhir di beberapa model, dan memuat dan membongkar model secara dinamis berdasarkan lalu lintas masuk. Dengan ini, Anda dapat menghemat biaya secara signifikan dan mencapai kinerja harga terbaik.

Dalam posting ini, kami menunjukkan cara menjalankan beberapa model pembelajaran mendalam di GPU dengan MME SageMaker.

MME SageMaker

MME SageMaker memungkinkan Anda untuk menerapkan beberapa model di belakang satu titik akhir inferensi yang mungkin berisi satu atau beberapa instans. Dengan MME, setiap instans dikelola untuk memuat dan melayani beberapa model. MME memungkinkan Anda mengurangi biaya hosting beberapa model yang meningkat secara linear dan menggunakan kembali infrastruktur di semua model.

Diagram berikut mengilustrasikan arsitektur MME SageMaker.

SageMaker MME mengunduh model secara dinamis dari Layanan Penyimpanan Sederhana Amazon (Amazon S3) saat dipanggil, alih-alih mengunduh semua model saat titik akhir pertama kali dibuat. Akibatnya, pemanggilan awal ke model mungkin melihat latensi inferensi yang lebih tinggi daripada inferensi berikutnya, yang dilengkapi dengan latensi rendah. Jika model sudah dimuat pada wadah saat dipanggil, maka langkah unduh dan muat dilewati dan model mengembalikan inferensi dengan latensi rendah. Misalnya, asumsikan Anda memiliki model yang hanya digunakan beberapa kali sehari. Ini dimuat secara otomatis sesuai permintaan, sedangkan model yang sering diakses disimpan dalam memori dan dipanggil dengan latensi rendah yang konsisten.

MME SageMaker dengan dukungan GPU

MME SageMaker dengan GPU bekerja menggunakan Server Inferensi NVIDIA Triton. NVIDIA Triton Inference Server adalah perangkat lunak penyajian inferensi sumber terbuka yang menyederhanakan proses penyajian inferensi dan memberikan kinerja inferensi tinggi. Triton mendukung semua kerangka kerja pelatihan dan inferensi utama, seperti TensorFlow, NVIDIA® TensorRT™, PyTorch, MXNet, Python, ONNX, XGBoost, Scikit-learn, RandomForest, OpenVINO, custom C++, dan banyak lagi. Menawarkan batching dinamis, berjalan bersamaan, kuantisasi pasca-pelatihan, dan konfigurasi model yang optimal untuk mencapai inferensi kinerja tinggi. Selain itu, Server Inferensi NVIDIA Triton telah diperluas untuk diimplementasikan Kontrak API MME, untuk berintegrasi dengan MME.

Diagram berikut mengilustrasikan alur kerja MME.

Langkah-langkah alur kerjanya adalah sebagai berikut:

1. MME SageMaker menerima permintaan permintaan HTTP untuk model tertentu menggunakan TargetModel dalam permintaan bersama dengan muatannya.
2. SageMaker mengarahkan lalu lintas ke instans yang tepat di belakang titik akhir tempat model target dimuat. SageMaker memahami pola lalu lintas di semua model di balik MME dan merutekan permintaan dengan cerdas.
3. SageMaker menangani manajemen model di belakang titik akhir, secara dinamis memuat model ke memori container, dan membongkar model berdasarkan armada bersama instans GPU untuk memberikan performa harga terbaik.
4. SageMaker mengunduh model secara dinamis dari Amazon S3 ke volume penyimpanan instans. Jika model yang dipanggil tidak tersedia pada volume penyimpanan instans, model tersebut diunduh ke volume penyimpanan instans. Jika volume penyimpanan instans mencapai kapasitas, SageMaker akan menghapus model yang tidak digunakan dari volume penyimpanan.
5. SageMaker memuat model ke memori wadah NVIDIA Triton pada instans yang dipercepat GPU dan melayani permintaan inferensi. Inti GPU digunakan bersama oleh semua model dalam satu instans. Jika model sudah dimuat dalam memori penampung, permintaan berikutnya akan dilayani lebih cepat karena SageMaker tidak perlu mengunduh dan memuatnya lagi.
6. SageMaker menangani pembentukan lalu lintas ke titik akhir MME dan mempertahankan salinan model yang optimal pada instans GPU untuk performa harga terbaik. Ini terus merutekan lalu lintas ke instance tempat model dimuat. Jika sumber daya instans mencapai kapasitas karena penggunaan yang tinggi, SageMaker akan membongkar model yang paling jarang digunakan dari penampung untuk mengosongkan sumber daya guna memuat model yang lebih sering digunakan.

MME SageMaker dapat menskalakan secara horizontal menggunakan kebijakan penskalaan otomatis, dan menyediakan instans komputasi GPU tambahan berdasarkan metrik seperti pemanggilan per instans dan penggunaan GPU untuk melayani lonjakan lalu lintas ke titik akhir MME.

Ikhtisar solusi

Dalam posting ini, kami menunjukkan cara menggunakan fitur baru MME SageMaker dengan GPU dengan kasus penggunaan computer vision. Untuk tujuan demonstrasi, kami menggunakan model jaringan saraf tiruan convolutional ResNet-50 yang dapat mengklasifikasikan gambar ke dalam 1,000 kategori. Kami membahas cara melakukan hal berikut:

• Gunakan wadah inferensi NVIDIA Triton pada MME SageMaker, menggunakan backend kerangka kerja model Triton yang berbeda seperti dan PyTorch dan TensorRT
• Konversikan model ResNet-50 ke format mesin TensorRT yang dioptimalkan dan terapkan dengan SageMaker MME
• Siapkan kebijakan penskalaan otomatis untuk MME
• Dapatkan wawasan tentang metrik instance dan pemanggilan menggunakan amazoncloudwatch

Buat artefak model

Bagian ini membahas langkah-langkah untuk menyiapkan model terlatih ResNet-50 untuk diterapkan pada MME SageMaker menggunakan konfigurasi model Server Inferensi Triton. Anda dapat mereproduksi semua langkah menggunakan buku catatan langkah-demi-langkah di GitHub.

Untuk posting ini, kami mendemonstrasikan penerapan dengan dua model. Namun, Anda dapat menyiapkan dan menerapkan ratusan model. Model mungkin atau mungkin tidak berbagi kerangka kerja yang sama.

Siapkan model PyTorch

Pertama, kami memuat model ResNet50 yang telah dilatih sebelumnya menggunakan paket model torchvision. Kami menyimpan model sebagai file model.pt dalam format TorchScript yang dioptimalkan dan serial. TorchScript mengkompilasi penerusan model ResNet50 dalam mode bersemangat dengan input contoh, jadi kami melewatkan satu contoh gambar RGB dengan tiga saluran warna berdimensi 224 x 224.

Kemudian kita perlu menyiapkan model untuk Triton Inference Server. Kode berikut menunjukkan repositori model untuk backend framework PyTorch. Triton menggunakan file model.pt yang ditempatkan di repositori model untuk menyajikan prediksi.

resnet
├── 1
│   └── model.pt
└── config.pbtxt

File konfigurasi model config.pbtxt harus menentukan nama model (resnet), platform dan properti backend (pytorch_libtorch), max_batch_size (128), dan tensor input dan output beserta tipe datanya (TYPE_FP32) informasi. Selain itu, Anda dapat menentukan instance_group dan dynamic_batching properti untuk mencapai inferensi kinerja tinggi. Lihat kode berikut:

name: "resnet"
platform: "pytorch_libtorch"
max_batch_size: 128
input {
  name: "INPUT__0"
  data_type: TYPE_FP32
  dims: 3
  dims: 224
  dims: 224
}
output {
  name: "OUTPUT__0"
  data_type: TYPE_FP32
  dims: 1000
}

Siapkan model TensorRT

NVIDIA TensorRT adalah SDK untuk inferensi pembelajaran mendalam berkinerja tinggi, dan mencakup pengoptimal inferensi pembelajaran mendalam dan waktu proses yang memberikan latensi rendah dan throughput tinggi untuk aplikasi inferensi. Kami menggunakan alat baris perintah trtexec untuk menghasilkan mesin serial TensorRT dari ONNX format model. Selesaikan langkah-langkah berikut untuk mengonversi model terlatih ResNet-50 ke NVIDIA TensorRT:

1. Ekspor model ResNet-50 yang telah dilatih sebelumnya ke dalam format ONNX menggunakan obor.onnx. Langkah ini menjalankan model satu kali untuk melacak jalannya dengan input sampel dan kemudian mengekspor model yang dilacak ke file yang ditentukan model.onnx.
2. Gunakan trtexec untuk membuat rencana mesin TensorRT dari model.onnx mengajukan. Anda dapat secara opsional mengurangi ketepatan perhitungan titik-mengambang, baik dengan menjalankannya dalam titik-mengambang 16-bit, atau dengan mengkuantisasi nilai titik-mengambang sehingga perhitungan dapat dilakukan menggunakan bilangan bulat 8-bit.

Kode berikut menunjukkan struktur repositori model untuk model TensorRT:

resnet
├── 1
│   └── model.plan
└── config.pbtxt

Untuk model TensorRT, kami menentukan tensorrt_plan sebagai platform dan masukan spesifikasi Tensor dari gambar berdimensi 224 x 224, yang memiliki saluran warna. Tensor keluaran dengan 1,000 dimensi bertipe TYPE_FP32, sesuai dengan kategori objek yang berbeda. Lihat kode berikut:

name: "resnet"
platform: "tensorrt_plan"
max_batch_size: 128
input {
  name: "input"
  data_type: TYPE_FP32
  dims: 3
  dims: 224
  dims: 224
}
output {
  name: "output"
  data_type: TYPE_FP32
  dims: 1000
}
model_warmup {
    name: "bs128 Warmup"
    batch_size: 128
    inputs: {
        key: "input"
        value: {
            data_type: TYPE_FP32
            dims: 3
            dims: 224
            dims: 224
            zero_data: false
        }
    }
}

Simpan artefak model di Amazon S3

SageMaker mengharapkan artefak model di .tar.gz format. Mereka juga harus memenuhi persyaratan wadah Triton seperti nama model, versi, config.pbtxt file, dan lainnya. tar folder yang berisi file model sebagai .tar.gz dan unggah ke Amazon S3:

!mkdir -p triton-serve-pt/resnet/1/
!mv -f workspace/model.pt triton-serve-pt/resnet/1/
!tar -C triton-serve-pt/ -czf resnet_pt_v0.tar.gz resnet
model_uri_pt = sagemaker_session.upload_data(path="resnet_pt_v0.tar.gz", key_prefix="resnet-mme-gpu")
!mkdir -p triton-serve-trt/resnet/1/
!mv -f workspace/model.plan triton-serve-trt/resnet/1/
!tar -C triton-serve-trt/ -czf resnet_trt_v0.tar.gz resnet
model_uri_trt = sagemaker_session.upload_data(path="resnet_trt_v0.tar.gz", key_prefix="resnet-mme-gpu")

Sekarang setelah kita mengunggah artefak model ke Amazon S3, kita dapat membuat MME SageMaker.

Terapkan model dengan MME

Kami sekarang menerapkan model ResNet-50 dengan dua backend kerangka kerja yang berbeda (PyTorch dan TensorRT) ke MME SageMaker.

Perhatikan bahwa Anda dapat menerapkan ratusan model, dan model dapat menggunakan kerangka kerja yang sama. Mereka juga dapat menggunakan kerangka kerja yang berbeda, seperti yang ditunjukkan dalam posting ini.

Kami menggunakan AWS SDK untuk Python (Boto3) Lebah buat_model, buat_endpoint_config, dan buat_titik akhir untuk membuat MME.

Tentukan wadah penyajian

Dalam definisi kontainer, tentukan model_data_url untuk menentukan direktori S3 yang berisi semua model yang digunakan SageMaker MME untuk memuat dan menyajikan prediksi. Mengatur Mode untuk MultiModel untuk menunjukkan bahwa SageMaker membuat titik akhir dengan spesifikasi wadah MME. Kami menyetel penampung dengan gambar yang mendukung penerapan MME dengan GPU. Lihat kode berikut:

container = {
"Image": ,
"ModelDataUrl": ,
"Mode": "MultiModel"
}

Buat objek multi-model

Gunakan klien SageMaker Boto3 untuk membuat model menggunakan create_model API. Kami meneruskan definisi wadah ke API model buat bersama dengan ModelName dan ExecutionRoleArn:

create_model_response = sm_client.create_model(
    ModelName=, ExecutionRoleArn=role, PrimaryContainer=container
)

Tentukan konfigurasi MME

Buat konfigurasi MME menggunakan create_endpoint_config API Boto3. Tentukan instans komputasi GPU yang dipercepat di InstanceType (kami menggunakan tipe instans g4dn.4xlarge). Kami menyarankan untuk mengonfigurasi titik akhir Anda dengan setidaknya dua instans. Hal ini memungkinkan SageMaker menyediakan serangkaian prediksi yang sangat tersedia di beberapa Availability Zone untuk model tersebut.

Berdasarkan temuan kami, Anda bisa mendapatkan performa harga yang lebih baik pada instans yang dioptimalkan ML dengan satu inti GPU. Oleh karena itu, dukungan MME untuk fitur GPU hanya diaktifkan untuk instans inti GPU tunggal. Untuk daftar lengkap instance yang didukung, lihat Jenis Instans GPU yang didukung.

create_endpoint_config_response = sm_client.create_endpoint_config(
    EndpointConfigName=,
    ProductionVariants=[
        {
            "InstanceType": "ml.g4dn.4xlarge",
            "InitialVariantWeight": 1,
            "InitialInstanceCount": 2,
            "ModelName": ,
            "VariantName": "AllTraffic",
        }
    ],
)

Buat MME

Dengan konfigurasi titik akhir sebelumnya, kami membuat MME SageMaker menggunakan buat_titik akhir API. SageMaker membuat MME, meluncurkan instance komputasi ML g4dn.4xlarge, dan menerapkan model PyTorch dan TensorRT ResNet-50 di dalamnya. Lihat kode berikut:

create_endpoint_response = sm_client.create_endpoint(
    EndpointName=, EndpointConfigName=
)

Panggil model target di MME

Setelah kami membuat titik akhir, kami dapat mengirim permintaan inferensi ke MME menggunakan invoke_enpoint API. Kami menentukan TargetModel dalam panggilan pemanggilan dan meneruskan muatan untuk setiap jenis model. Kode berikut adalah contoh permintaan untuk model PyTorch dan model TensorRT:

runtime_sm_client.invoke_endpoint(
    EndpointName=,
    ContentType="application/octet-stream",
    Body=json.dumps(pt_payload),
    TargetModel='resnet_pt_v0.tar.gz', #PyTorch Model
)
runtime_sm_client.invoke_endpoint(
    EndpointName=, 
    ContentType="application/octet-stream", 
    Body=json.dumps(trt_payload),
    TargetModel='resnet_trt_v0.tar.gz' #TensorRT Model
)

Siapkan kebijakan penskalaan otomatis untuk GPU MME

MME SageMaker mendukung penskalaan otomatis untuk model yang dihosting. Penskalaan otomatis secara dinamis menyesuaikan jumlah instans yang disediakan untuk model sebagai respons terhadap perubahan beban kerja Anda. Saat beban kerja meningkat, penskalaan otomatis menghadirkan lebih banyak instans secara online. Saat beban kerja berkurang, penskalaan otomatis menghapus instans yang tidak perlu sehingga Anda tidak membayar instans yang disediakan yang tidak Anda gunakan.

Dalam kebijakan penskalaan berikut, kami menggunakan metrik khusus GPUUtilization dalam TargetTrackingScalingPolicyConfiguration konfigurasi dan atur a TargetValue of 60.0 untuk nilai target metrik tersebut. Kebijakan penskalaan otomatis ini menyediakan instance tambahan hingga MaxCapacity ketika penggunaan GPU lebih dari 60%.

auto_scaling_client = boto3.client('application-autoscaling')

resource_id='endpoint/' +  + '/variant/' + 'AllTraffic' 
response = auto_scaling_client.register_scalable_target(
    ServiceNamespace='sagemaker',
    ResourceId=resource_id,
    ScalableDimension='sagemaker:variant:DesiredInstanceCount',
    MinCapacity=1,
    MaxCapacity=5
)

response = auto_scaling_client.put_scaling_policy(
    PolicyName='GPUUtil-ScalingPolicy',
    ServiceNamespace='sagemaker',
    ResourceId=resource_id,
    ScalableDimension='sagemaker:variant:DesiredInstanceCount', 
    PolicyType='TargetTrackingScaling',
    TargetTrackingScalingPolicyConfiguration={
        'TargetValue': 60.0, 
        'CustomizedMetricSpecification':
        {
            'MetricName': 'GPUUtilization',
            'Namespace': '/aws/sagemaker/Endpoints',
            'Dimensions': [
                {'Name': 'EndpointName', 'Value':  },
                {'Name': 'VariantName','Value': 'AllTraffic'}
            ],
            'Statistic': 'Average',
            'Unit': 'Percent'
        },
        'ScaleInCooldown': 600,
        'ScaleOutCooldown': 200 
    }
)

Sebaiknya gunakan GPUUtilization or InvocationsPerInstance untuk mengonfigurasi kebijakan penskalaan otomatis untuk MME Anda. Untuk lebih jelasnya, lihat Tetapkan Kebijakan Penskalaan Otomatis untuk Penerapan Titik Akhir Multi-Model

Metrik CloudWatch untuk MME GPU

MME SageMaker menyediakan metrik tingkat instans berikut untuk dipantau:

• DimuatModelCount – Jumlah model yang dimuat dalam wadah
• Pemanfaatan GPU – Persentase unit GPU yang digunakan oleh container
• Pemanfaatan Memori GPU – Persentase memori GPU yang digunakan oleh wadah
• Pemanfaatan Disk – Persentase ruang disk yang digunakan oleh wadah

Metrik ini memungkinkan Anda merencanakan pemanfaatan sumber daya instans GPU secara efektif. Pada grafik berikut, kita melihat GPUMemoryUtilization adalah 38.3% ketika lebih dari 16 model ResNet-50 dimuat dalam wadah. Jumlah pemanfaatan masing-masing inti CPU (CPUUtilization) adalah 60.9%, dan persentase memori yang digunakan oleh wadah (MemoryUtilization) adalah 9.36%.

MME SageMaker juga menyediakan metrik pemuatan model untuk mendapatkan wawasan tingkat pemanggilan model:

• ModelMemuatWaktuTunggu – Interval waktu untuk model yang akan diunduh atau dimuat
• ModelWaktu Bongkar – Interval waktu untuk membongkar model dari wadah
• Waktu Pengunduhan Model – Saatnya mengunduh model dari Amazon S3
• ModelCacheHit – Jumlah pemanggilan ke model yang sudah dimuat ke wadah

Dalam grafik berikut, kita dapat mengamati bahwa butuh 8.22 detik bagi model untuk merespons permintaan inferensi (ModelLatency), dan 24.1 milidetik ditambahkan ke latensi ujung ke ujung karena overhead SageMaker (OverheadLatency). Kami juga dapat melihat metrik kesalahan dari panggilan untuk memanggil panggilan API titik akhir, seperti Invocation4XXErrors dan Invocation5XXErrors.

Untuk informasi selengkapnya tentang metrik MME CloudWatch, lihat Metrik CloudWatch untuk Penerapan Titik Akhir Multi-Model.

Kesimpulan

Dalam postingan ini, Anda mempelajari tentang dukungan multi-model SageMaker baru untuk GPU, yang memungkinkan Anda untuk menghosting ratusan model deep learning secara hemat biaya pada perangkat keras komputasi yang dipercepat. Anda telah mempelajari cara menggunakan Server Inferensi NVIDIA Triton, yang membuat konfigurasi repositori model untuk backend kerangka kerja yang berbeda, dan cara menerapkan MME dengan penskalaan otomatis. Fitur ini akan memungkinkan Anda untuk menskalakan ratusan model yang sangat dipersonalisasi yang disesuaikan untuk memenuhi pengalaman pengguna akhir yang unik dalam aplikasi AI. Anda juga dapat memanfaatkan fitur ini untuk mencapai kinerja harga yang diperlukan untuk aplikasi inferensi Anda menggunakan GPU pecahan.

Untuk memulai dengan dukungan MME untuk GPU, lihat Dukungan titik akhir multi-model untuk GPU.

Tentang penulis

Dhawal Patel adalah Arsitek Pembelajaran Mesin Utama di AWS. Dia telah bekerja dengan organisasi mulai dari perusahaan besar hingga perusahaan rintisan menengah pada masalah yang terkait dengan komputasi terdistribusi dan kecerdasan buatan. Dia berfokus pada pembelajaran mendalam, termasuk NLP dan domain visi komputer. Dia membantu pelanggan mencapai inferensi model performa tinggi di Amazon SageMaker.

Vikram Elango adalah Arsitek Solusi Spesialis AI/ML Senior di Amazon Web Services, yang berbasis di Virginia, AS. Vikram membantu pelanggan industri keuangan dan asuransi global dengan desain, implementasi, dan kepemimpinan pemikiran untuk membangun dan menerapkan aplikasi pembelajaran mesin dalam skala besar. Dia saat ini fokus pada pemrosesan bahasa alami, AI yang bertanggung jawab, pengoptimalan inferensi, dan penskalaan ML di seluruh perusahaan. Di waktu senggangnya, ia senang bepergian, mendaki gunung, memasak, dan berkemah bersama keluarganya.

Saurabh Trikande adalah Manajer Produk Senior untuk Inferensi Amazon SageMaker. Dia bersemangat bekerja dengan pelanggan dan termotivasi oleh tujuan mendemokratisasi pembelajaran mesin. Dia berfokus pada tantangan inti yang terkait dengan penerapan aplikasi ML yang kompleks, model ML multi-penyewa, pengoptimalan biaya, dan membuat penerapan model pembelajaran mendalam lebih mudah diakses. Di waktu luangnya, Saurabh menikmati hiking, belajar tentang teknologi inovatif, mengikuti TechCrunch, dan menghabiskan waktu bersama keluarganya.

Deepti Ragha adalah Insinyur Pengembangan Perangkat Lunak di tim Amazon SageMaker. Pekerjaannya saat ini berfokus pada pembuatan fitur untuk menghosting model pembelajaran mesin secara efisien. Di waktu senggangnya, dia suka jalan-jalan, mendaki gunung, dan menanam tanaman.

Nikhil Kulkarni adalah pengembang perangkat lunak dengan AWS Machine Learning, yang berfokus untuk membuat beban kerja pembelajaran mesin lebih berperforma di cloud dan merupakan salah satu pembuat AWS Deep Learning Containers untuk pelatihan dan inferensi. Dia bersemangat tentang Sistem Pembelajaran Mendalam yang didistribusikan. Di luar pekerjaan, dia suka membaca buku, bermain gitar, dan membuat pizza.

Jia Hong Liu adalah Arsitek Solusi di tim Penyedia Layanan Cloud di NVIDIA. Dia membantu klien dalam mengadopsi pembelajaran mesin dan solusi AI yang memanfaatkan komputasi akselerasi NVIDIA untuk mengatasi tantangan pelatihan dan inferensi mereka. Di waktu senggang, ia menikmati origami, proyek DIY, dan bermain basket.

Eliut Triana adalah Manajer Hubungan Pengembang di tim NVIDIA-AWS. Dia menghubungkan pemimpin produk, pengembang, dan ilmuwan Amazon dan AWS dengan teknologi NVIDIA dan pemimpin produk untuk mempercepat beban kerja Amazon ML/DL, produk EC2, dan layanan AI AWS. Selain itu, Eliuth adalah pengendara sepeda gunung, pemain ski, dan pemain poker yang bersemangat.

Maximiliano Maccanti adalah Insinyur Utama di AWS saat ini dengan DynamoDB, saya berada di tim peluncuran SageMaker di re:Invent 2017 dan menghabiskan 5 tahun berikutnya di platform hosting dengan menambahkan semua jenis fitur yang dihadapi pelanggan. Di waktu luang saya, saya mengumpulkan, memperbaiki, dan bermain dengan konsol videogame vintage.