Terapkan BLOOM-176B dan OPT-30B di Amazon SageMaker dengan inferensi model besar Deep Learning Containers dan DeepSpeed

Beberapa tahun terakhir telah melihat perkembangan pesat di bidang pembelajaran yang mendalam. Meskipun perangkat keras telah meningkat, seperti dengan akselerator generasi terbaru dari NVIDIA dan Amazon, praktisi pembelajaran mesin (ML) tingkat lanjut masih sering menghadapi masalah dalam menerapkan model pembelajaran mendalam mereka yang besar untuk aplikasi seperti pemrosesan bahasa alami (NLP).

Dalam posting sebelumnya, kami membahas kemampuan dan pengaturan yang dapat dikonfigurasi in Penerapan model Amazon SageMaker yang dapat membuat inferensi dengan model besar ini lebih mudah. Hari ini, kami mengumumkan yang baru Amazon SageMaker Deep Learning Container (DLC) yang dapat Anda gunakan untuk memulai inferensi model besar dalam hitungan menit. Ini DLC mengemas beberapa pustaka sumber terbuka paling populer untuk inferensi paralel model, seperti DeepSpeed ​​dan Hugging Face Accelerate.

Dalam posting ini, kami menggunakan DLC inferensi model besar SageMaker baru untuk menerapkan dua model NLP besar paling populer: BigScience's MEKAR-176B dan Meta MEMILIH-30B dari repositori Hugging Face. Secara khusus, kami menggunakan teknik penyajian Deep Java Library (DJL) dan paralelisme tensor dari DeepSpeed ​​untuk mencapai latensi 0.1 detik per token dalam kasus penggunaan pembuatan teks.

Anda dapat menemukan buku catatan contoh lengkap kami di Repositori GitHub.

Teknik inferensi model besar

Model bahasa baru-baru ini meledak dalam ukuran dan popularitas. Dengan akses mudah dari kebun binatang model seperti Hugging Face dan peningkatan akurasi dan kinerja dalam tugas NLP seperti klasifikasi dan pembuatan teks, praktisi semakin menjangkau model besar ini. Namun, model besar sering kali terlalu besar untuk dimasukkan ke dalam memori akselerator tunggal. Misalnya, model BLOOM-176B dapat memerlukan lebih dari 350 gigabyte memori akselerator, yang jauh melebihi kapasitas akselerator perangkat keras yang tersedia saat ini. Ini memerlukan penggunaan teknik paralel model dari perpustakaan seperti DeepSpeed ​​dan Hugging Face Accelerate untuk mendistribusikan model ke beberapa akselerator untuk inferensi. Dalam posting ini, kami menggunakan Wadah inferensi model besar SageMaker untuk menghasilkan dan membandingkan kinerja latensi dan throughput menggunakan dua pustaka sumber terbuka ini.

DeepSpeed ​​dan Accelerate menggunakan teknik berbeda untuk mengoptimalkan model bahasa besar untuk inferensi. Perbedaan utamanya adalah DeepSpeed penggunaan kernel yang dioptimalkan. Kernel ini dapat secara dramatis meningkatkan latensi inferensi dengan mengurangi kemacetan dalam grafik komputasi model. Kernel yang dioptimalkan bisa jadi sulit untuk dikembangkan dan biasanya khusus untuk arsitektur model tertentu; DeepSpeed ​​mendukung model besar yang populer seperti OPT dan BLOOM dengan kernel yang dioptimalkan ini. Sebaliknya, perpustakaan Akselerasi Hugging Face tidak menyertakan kernel yang dioptimalkan pada saat penulisan. Seperti yang kami diskusikan di bagian hasil kami, perbedaan ini bertanggung jawab atas sebagian besar keunggulan kinerja yang dimiliki DeepSpeed ​​​​di atas Akselerasi.

Perbedaan kedua antara DeepSpeed ​​dan Accelerate adalah jenis paralelisme model. Accelerate menggunakan paralelisme pipa untuk mempartisi model di antara lapisan tersembunyi model, sedangkan DeepSpeed ​​menggunakan paralelisme tensor untuk mempartisi lapisan itu sendiri. Paralelisme saluran pipa adalah pendekatan fleksibel yang mendukung lebih banyak jenis model dan dapat meningkatkan throughput ketika ukuran batch yang lebih besar digunakan. Paralelisme tensor membutuhkan lebih banyak komunikasi antar GPU karena lapisan model dapat tersebar di beberapa perangkat, tetapi dapat meningkatkan latensi inferensi dengan melibatkan beberapa GPU secara bersamaan. Anda dapat mempelajari lebih lanjut tentang teknik paralelisme di Pengantar Model Paralelisme dan Model Paralelisme.

Ikhtisar solusi

Untuk menghosting model bahasa besar secara efektif, kami memerlukan fitur dan dukungan di area utama berikut:

• Membangun dan menguji solusi – Mengingat sifat pengembangan ML yang berulang, kita memerlukan kemampuan untuk membangun, mengulangi dengan cepat, dan menguji bagaimana perilaku titik akhir inferensi saat model ini dihosting, termasuk kemampuan untuk gagal dengan cepat. Model ini biasanya dapat dihosting hanya pada instans yang lebih besar seperti p4dn atau g5, dan mengingat ukuran model, diperlukan beberapa saat untuk memutar instans inferensi dan menjalankan iterasi pengujian apa pun. Pengujian lokal biasanya memiliki kendala karena Anda memerlukan instans serupa dalam ukuran untuk diuji, dan model ini tidak mudah diperoleh.
• Menerapkan dan menjalankan dalam skala – File model perlu dimuat ke instance inferensi, yang menghadirkan tantangan tersendiri mengingat ukurannya. Tar / Un-Tar sebagai contoh untuk Bloom-176B membutuhkan waktu sekitar 1 jam untuk membuat dan satu jam lagi untuk memuat. Kami membutuhkan mekanisme alternatif untuk memungkinkan akses mudah ke file model.
• Memuat model sebagai singleton – Untuk proses multi-pekerja, kita perlu memastikan model dimuat hanya sekali sehingga kita tidak mengalami kondisi balapan dan selanjutnya menghabiskan sumber daya yang tidak perlu. Dalam posting ini, kami menunjukkan cara memuat langsung dari Layanan Penyimpanan Sederhana Amazon (Amazon S3). Namun, ini hanya berfungsi jika kita menggunakan pengaturan default DJL. Selain itu, penskalaan titik akhir apa pun harus dapat ditingkatkan dalam beberapa menit, yang memerlukan pertimbangan ulang bagaimana model dapat dimuat dan didistribusikan.
• Kerangka kerja sharding – Model ini biasanya perlu , biasanya dengan mekanisme paralelisme tensor atau dengan pipeline sharding sebagai teknik sharding yang umum, dan kami memiliki konsep lanjutan seperti ZeRO sharding yang dibangun di atas sharding tensor. Untuk informasi lebih lanjut tentang teknik sharding, lihat Model Paralelisme. Untuk mencapainya, kita dapat memiliki berbagai kombinasi dan menggunakan kerangka kerja dari NIVIDIA, DeepSpeed, dan lainnya. Ini membutuhkan kemampuan untuk menguji BYOC atau menggunakan wadah 1P dan beralih ke solusi dan menjalankan tes pembandingan. Anda mungkin juga ingin menguji berbagai opsi hosting seperti asinkron, tanpa server, dan lainnya.
• Pilihan perangkat keras – Pilihan Anda dalam perangkat keras ditentukan oleh semua poin yang disebutkan di atas dan pola lalu lintas lebih lanjut, kebutuhan kasus penggunaan, dan ukuran model.

Dalam posting ini, kami menggunakan kernel DeepSpeed ​​yang dioptimalkan dan teknik paralelisme tensor untuk meng-host BLOOM-176B dan OPT-30B di SageMaker. Kami juga membandingkan hasil dari Accelerate untuk menunjukkan manfaat kinerja kernel yang dioptimalkan dan paralelisme tensor. Untuk informasi lebih lanjut tentang DeepSpeed ​​dan Accelerate, lihat Inferensi DeepSpeed: Mengaktifkan Inferensi Model Transformer yang Efisien pada Skala yang Belum Pernah Ada Sebelumnya dan Inferensi BLOOM Sangat Cepat dengan DeepSpeed ​​dan Accelerate.

Kami menggunakan DJLServing sebagai solusi penyajian model dalam contoh ini. DJLServing adalah solusi penyajian model universal berkinerja tinggi yang didukung oleh Deep Java Library (DJL) yang merupakan bahasa pemrograman agnostik. Untuk mempelajari lebih lanjut tentang DJL dan DJLServing, lihat Terapkan model besar di Amazon SageMaker menggunakan inferensi paralel model DJLServing dan DeepSpeed.

Perlu dicatat bahwa kernel yang dioptimalkan dapat menghasilkan perubahan presisi dan grafik komputasi yang dimodifikasi, yang secara teoritis dapat menghasilkan perubahan perilaku model. Meskipun ini kadang-kadang dapat mengubah hasil inferensi, kami tidak mengharapkan perbedaan ini secara material berdampak pada metrik evaluasi dasar model. Namun demikian, praktisi disarankan untuk mengkonfirmasi keluaran model seperti yang diharapkan saat menggunakan kernel ini.

Langkah-langkah berikut menunjukkan cara menerapkan model BLOOM-176B di SageMaker menggunakan DJLServing dan wadah inferensi model besar SageMaker. Contoh lengkap juga tersedia di kami Repositori GitHub.

Menggunakan gambar DLC DJLServing SageMaker

Gunakan kode berikut untuk menggunakan gambar DLC DJLServing SageMaker setelah mengganti wilayah dengan wilayah spesifik tempat Anda menjalankan notebook:

763104351884.dkr.ecr..amazonaws.com/djl-inference:0.19.0-deepspeed0.7.3-cu113
# example uri might be like 763104351884.dkr.ecr.us-east-1.amazonaws.com/djl-inference:0.19.0-deepspeed0.7.3-cu113

Buat file model kami

Pertama, kita buat file bernama serving.properties yang hanya berisi satu baris kode. Ini memberitahu server model DJL untuk menggunakan mesin DeepSpeed. File tersebut berisi kode berikut:

engine=DeepSpeed

serving.properties adalah file yang ditentukan oleh DJLServing yang digunakan untuk mengonfigurasi konfigurasi per model.

Selanjutnya, kita buat model.py file, yang mendefinisikan kode yang diperlukan untuk memuat dan kemudian melayani model. Dalam kode kami, kami membaca di TENSOR_PARALLEL_DEGREE variabel lingkungan (nilai default adalah 1). Ini menetapkan jumlah perangkat tempat modul paralel tensor didistribusikan. Perhatikan bahwa DeepSpeed ​​menyediakan beberapa definisi partisi bawaan, termasuk satu untuk model BLOOM. Kami menggunakannya dengan menentukan replace_method dan relpace_with_kernel_inject. Jika Anda memiliki model yang disesuaikan dan membutuhkan DeepSpeed ​​untuk mempartisi secara efektif, Anda perlu mengubah relpace_with_kernel_inject untuk false dan tambahkan injection_policy untuk membuat partisi runtime berfungsi. Untuk informasi lebih lanjut, lihat Inisialisasi untuk Inferensi. Sebagai contoh, kami menggunakan model BLOOM yang telah dipartisi sebelumnya di DeepSpeed.

Kedua, di model.py file, kami juga memuat model dari Amazon S3 setelah titik akhir diputar. Model dimuat ke dalam /tmp ruang pada wadah karena SageMaker memetakan /tmp ke Toko Blok Elastis Amazon (Amazon EBS) volume yang dipasang saat kami menentukan parameter pembuatan titik akhir VolumeSizeInGB. Untuk instans seperti p4dn, yang sudah dibuat sebelumnya dengan instans volume, kami dapat terus memanfaatkannya /tmp pada wadah. Lihat kode berikut:

from djl_python import Input, Output
import os
import deepspeed
import torch
import torch.distributed as dist
import sys
import subprocess
import time
from glob import glob
from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
from transformers.models.opt.modeling_opt import OPTDecoderLayer

predictor = None

def check_config():
    local_rank = os.getenv('LOCAL_RANK')
    
    if not local_rank:
        return False
    return True
    
def get_model():

    if not check_config():
        raise Exception("DJL:DeepSpeed configurations are not default. This code does not support non default configurations") 
    
    tensor_parallel = int(os.getenv('TENSOR_PARALLEL_DEGREE', '1'))
    local_rank = int(os.getenv('LOCAL_RANK', '0'))
    model_dir = "/tmp/model"
    bucket = os.environ.get("MODEL_S3_BUCKET")
    key_prefix = os.environ.get("MODEL_S3_PREFIX")
    print(f"rank: {local_rank}")
    if local_rank == 0:
        if f"{model_dir}/DONE" not in glob(f"{model_dir}/*"):
            print("Starting Model downloading files")
            try:
                proc_run = subprocess.run(
                    ["aws", "s3", "cp", "--recursive", f"s3://{bucket}/{key_prefix}", model_dir]
                )
                print("Model downloading finished")
                # write file when download complete. Could use dist.barrier() but this makes it easier to check if model is downloaded in case of retry
                with open(f"{model_dir}/DONE", "w") as f:
                    f.write("download_complete")
                    
                proc_run.check_returncode() # to throw the error in case there was one
                
            except subprocess.CalledProcessError as e:
                print ( "Model download failed: Error:nreturn code: ", e.returncode, "nOutput: ", e.stderr )
                raise # FAIL FAST  
                               
    dist.barrier()
                
    
    tokenizer = AutoTokenizer.from_pretrained(model_dir)
    
    # has to be FP16 as Int8 model loading not yet supported
    with deepspeed.OnDevice(dtype=torch.float16, device="meta"):
        model = AutoModelForCausalLM.from_config(
            AutoConfig.from_pretrained(model_dir), torch_dtype=torch.bfloat16
        )
    model = model.eval()
    
    model = deepspeed.init_inference(
        model,
        mp_size=tensor_parallel,
        dtype=torch.int8,
        base_dir = model_dir,
        checkpoint=os.path.join(model_dir, "ds_inference_config.json"),
        replace_method='auto',
        replace_with_kernel_inject=True
    )

    model = model.module
    dist.barrier()
    return model, tokenizer

DJLServing mengelola instalasi runtime pada paket pip apa pun yang ditentukan dalam requirement.txt. File ini akan memiliki:

awscli
boto3

Kami telah membuat direktori bernama code dan model.py, serving.properties, dan requirements.txt file sudah dibuat di direktori ini. Untuk melihat file, Anda dapat menjalankan kode berikut dari terminal:

mkdir -p code
cat code/model.py 
cat code/serving.properties 
cat code/requirements.txt 

Gambar berikut menunjukkan struktur dari model.tar.gz.

Terakhir, kami membuat file model dan mengunggahnya ke Amazon S3:

tar cvfz model.tar.gz code
s3_code_artifact = sess.upload_data("model.tar.gz", bucket, s3_code_prefix)

Unduh dan simpan model dari Hugging Face (Opsional)

Kami telah menyediakan langkah-langkah di bagian ini jika Anda ingin mengunduh model ke Amazon S3 dan menggunakannya dari sana. Langkah-langkahnya disediakan dalam file Jupyter di GitHub. Tangkapan layar berikut menunjukkan cuplikan langkah-langkahnya.

Buat model SageMaker

Kami sekarang membuat Model SageMaker. Kami menggunakan Registry Kontainer Elastis Amazon (Amazon ECR) gambar yang disediakan oleh dan artefak model dari langkah sebelumnya untuk membuat model SageMaker. Dalam pengaturan model, kami mengonfigurasi TENSOR_PARALLEL_DEGREE=8, yang berarti model dipartisi di sepanjang 8 GPU. Lihat kode berikut:

PrimaryContainer={
        "Image": inference_image_uri,
        "ModelDataUrl": s3_code_artifact,
        "Environment": {
            "MODEL_S3_BUCKET": bucket,
            "MODEL_S3_PREFIX": s3_model_prefix,
            "TENSOR_PARALLEL_DEGREE": "8",
},

Setelah Anda menjalankan sel sebelumnya di file Jupyter, Anda melihat output yang mirip dengan berikut ini:

{
    "ModelArn": "arn:aws:sagemaker:us-east-1::model/bloom-djl-ds-"
}

Buat titik akhir SageMaker

Anda dapat menggunakan instans apa pun dengan beberapa GPU untuk pengujian. Dalam demo ini, kami menggunakan instance p4d.24xlarge. Dalam kode berikut, perhatikan bagaimana kita mengatur ModelDataDownloadTimeoutInSeconds, ContainerStartupHealthCheckTimeoutInSeconds, dan VolumeSizeInGB parameter untuk mengakomodasi ukuran model yang besar. Itu VolumeSizeInGB parameter berlaku untuk instans GPU yang mendukung lampiran volume EBS.

endpoint_config_response = sm_client.create_endpoint_config(
    EndpointConfigName=endpoint_config_name,
    ProductionVariants=[
        {
            "VariantName": "variant1",
            "ModelName": model_name,
            "InstanceType": "ml.p4d.24xlarge",
            "InitialInstanceCount": 1,
            #"VolumeSizeInGB" : 200,
            "ModelDataDownloadTimeoutInSeconds": 2400,
            "ContainerStartupHealthCheckTimeoutInSeconds": 2400,
        },
    ],
)'

Terakhir, kami membuat titik akhir SageMaker:

create_endpoint_response = sm_client.create_endpoint(
    EndpointName=f"{endpoint_name}", EndpointConfigName=endpoint_config_name
)

Anda melihatnya dicetak dalam kode berikut:

{
    "EndpointArn": "arn:aws:sagemaker:us-east-1::endpoint/bloom-djl-ds-"
}

Memulai titik akhir mungkin memerlukan beberapa saat. Anda dapat mencoba beberapa kali lagi jika Anda mengalami InsufficientInstanceCapacity kesalahan, atau Anda dapat mengajukan permintaan ke AWS untuk meningkatkan batas di akun Anda.

Penyesuaian kinerja

Jika Anda bermaksud menggunakan posting ini dan notebook yang menyertainya dengan model yang berbeda, Anda mungkin ingin menjelajahi beberapa parameter yang dapat disetel yang ditawarkan SageMaker, DeepSpeed, dan DJL. Bereksperimen secara berulang dengan parameter ini dapat berdampak material pada latensi, throughput, dan biaya model besar yang dihosting. Untuk mempelajari lebih lanjut tentang parameter penyetelan seperti jumlah pekerja, derajat paralelisme tensor, ukuran antrian pekerjaan, dan lainnya, lihat Konfigurasi penyajian DJL dan Terapkan model besar di Amazon SageMaker menggunakan inferensi paralel model DJLServing dan DeepSpeed.

Hasil

Dalam postingan ini, kami menggunakan DeepSpeed ​​untuk menghosting BLOOM-176B dan OPT-30B pada instans SageMaker ML. Tabel berikut merangkum hasil kinerja kami, termasuk perbandingan dengan Akselerasi Hugging Face. Latensi mencerminkan jumlah milidetik yang diperlukan untuk menghasilkan string 256-token empat kali (batch_size=4) dari modelnya. Throughput mencerminkan jumlah token yang dihasilkan per detik untuk setiap pengujian. Untuk Hugging Face Accelerate, kami menggunakan pemuatan default library dengan pemetaan memori GPU. Untuk DeepSpeed, kami menggunakan mekanisme pemuatan pos pemeriksaan yang lebih cepat.

Dari perspektif latensi, DeepSpeed ​​sekitar 3.4 kali lebih cepat untuk BLOOM-176B dan 5.6 kali lebih cepat untuk OPT-30B daripada Accelerate. Kernel DeepSpeed ​​yang dioptimalkan bertanggung jawab atas sebagian besar perbedaan latensi ini. Mengingat hasil ini, sebaiknya gunakan DeepSpeed ​​daripada Accelerate jika model pilihan Anda didukung.

Perlu juga diperhatikan bahwa waktu pemuatan model dengan DeepSpeed ​​jauh lebih singkat, menjadikannya pilihan yang lebih baik jika Anda mengantisipasi kebutuhan untuk meningkatkan jumlah titik akhir dengan cepat. Teknik paralelisme pipeline Accelerate yang lebih fleksibel mungkin merupakan opsi yang lebih baik jika Anda memiliki model atau presisi model yang tidak didukung oleh DeepSpeed.

Hasil ini juga menunjukkan perbedaan latensi dan throughput dari ukuran model yang berbeda. Dalam pengujian kami, OPT-30B menghasilkan 2.4 kali jumlah token per unit waktu daripada BLOOM-176B pada jenis instans yang lebih dari tiga kali lebih murah. Berdasarkan harga per unit throughput, OPT-30B pada instans g5.24xl adalah 8.9 kali lebih baik daripada BLOOM-176B pada instans p4d.24xl. Jika Anda memiliki latensi, throughput, atau batasan biaya yang ketat, pertimbangkan untuk menggunakan model sekecil mungkin yang akan tetap memenuhi persyaratan fungsional.

Membersihkan

Sebagai bagian dari praktik terbaik, selalu disarankan untuk menghapus instans yang tidak digunakan. Kode di bawah ini menunjukkan kepada Anda cara menghapus instance.

# - Delete the end point
sm_client.delete_endpoint(EndpointName=endpoint_name)

# - In case the end point failed we still want to delete the model
sm_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)
sm_client.delete_model(ModelName=model_name)

Secara opsional, hapus titik pemeriksaan model dari S3 Anda

!aws s3 rm --recursive s3:///{s3_model_prefix}

Kesimpulan

Dalam posting ini, kami menunjukkan cara menggunakan wadah inferensi model besar SageMaker untuk meng-host dua model bahasa besar, BLOOM-176B dan OPT-30B. Kami menggunakan teknik paralel model DeepSpeed ​​dengan beberapa GPU pada satu instans SageMaker ML.

Untuk detail selengkapnya tentang Amazon SageMaker dan kemampuan inferensi model besarnya, lihat Amazon SageMaker sekarang mendukung penerapan model besar melalui ukuran volume yang dapat dikonfigurasi dan kuota waktu habis dan Inferensi waktu nyata.

Tentang penulis

Simon Zamarin adalah Arsitek Solusi AI / ML yang fokus utamanya membantu pelanggan mengekstrak nilai dari aset data mereka. Di waktu luangnya, Simon menikmati menghabiskan waktu bersama keluarga, membaca fiksi ilmiah, dan mengerjakan berbagai proyek rumah DIY.

Rupinder Grewal adalah Arsitek Solusi Spesialis Sr Ai/ML dengan AWS. Dia saat ini berfokus pada penyajian model dan MLOps di SageMaker. Sebelum peran ini, ia telah bekerja sebagai Insinyur Pembelajaran Mesin yang membangun dan menjadi model hosting. Di luar pekerjaan ia menikmati bermain tenis dan bersepeda di jalur gunung.

Frank Liu adalah Insinyur Perangkat Lunak untuk AWS Deep Learning. Dia berfokus pada membangun alat pembelajaran mendalam yang inovatif untuk insinyur perangkat lunak dan ilmuwan. Di waktu luangnya, dia menikmati hiking bersama teman dan keluarga.

Alan Tan adalah Manajer Produk Senior dengan upaya terkemuka SageMaker pada inferensi model besar. Dia bersemangat menerapkan Machine Learning ke area Analytics. Di luar pekerjaan, dia menikmati alam bebas.

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 Deep learning termasuk domain NLP dan Computer Vision. Dia membantu pelanggan mencapai inferensi model kinerja tinggi di SageMaker.

Qinglan adalah Insinyur Pengembangan Perangkat Lunak di AWS. Dia telah mengerjakan beberapa produk yang menantang di Amazon, termasuk solusi inferensi ML kinerja tinggi dan sistem logging kinerja tinggi. Tim Qing berhasil meluncurkan model Billion-parameter pertama di Amazon Advertising dengan latensi yang sangat rendah. Qing memiliki pengetahuan mendalam tentang pengoptimalan infrastruktur dan akselerasi Deep Learning.

Qing Wei Li adalah Spesialis Pembelajaran Mesin di Amazon Web Services. Dia menerima gelar Ph.D. dalam Riset Operasi setelah dia melanggar akun hibah penelitian penasihatnya dan gagal memberikan Hadiah Nobel yang dia janjikan. Saat ini dia membantu pelanggan di industri layanan keuangan dan asuransi membangun solusi pembelajaran mesin di AWS. Di waktu luangnya, dia suka membaca dan mengajar.

Robert Van Dusen adalah Manajer Produk Senior dengan Amazon SageMaker. Dia memimpin pengoptimalan model pembelajaran mendalam untuk aplikasi seperti inferensi model besar.

Siddharth Venkatesan adalah Insinyur Perangkat Lunak di AWS Deep Learning. Dia saat ini berfokus pada membangun solusi untuk inferensi model besar. Sebelum di AWS, dia bekerja di Amazon Grocery org yang membangun fitur pembayaran baru untuk pelanggan di seluruh dunia. Di luar pekerjaan, ia menikmati bermain ski, alam terbuka, dan menonton olahraga.